pydantic API Reference

Python Library Documentation: class AfterValidator in module pydantic.functional_validators

class AfterValidator(builtins.object)
 |  AfterValidator(func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction') -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [field *after* validators](../concepts/validators.md#field-after-validator)
 |
 |  A metadata class that indicates that a validation should be applied **after** the inner validation logic.
 |
 |  Attributes:
 |      func: The validator function.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic import AfterValidator, BaseModel, ValidationError
 |
 |      MyInt = Annotated[int, AfterValidator(lambda v: v + 1)]
 |
 |      class Model(BaseModel):
 |          a: MyInt
 |
 |      print(Model(a=1).a)
 |      #> 2
 |
 |      try:
 |          Model(a='a')
 |      except ValidationError as e:
 |          print(e.json(indent=2))
 |          '''
 |          [
 |            {
 |              "type": "int_parsing",
 |              "loc": [
 |                "a"
 |              ],
 |              "msg": "Input should be a valid integer, unable to parse string as an integer",
 |              "input": "a",
 |              "url": "https://errors.pydantic.dev/2/v/int_parsing"
 |            }
 |          ]
 |          '''
 |      ```
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.NoInfoValidatorFunction | core...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.No...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func',)

Python Library Documentation: class AliasChoices in module pydantic.aliases

class AliasChoices(builtins.object)
 |  AliasChoices(first_choice: 'str | AliasPath', *choices: 'str | AliasPath') -> 'None'
 |
 |  !!! abstract "Usage Documentation"
 |      [`AliasPath` and `AliasChoices`](../concepts/alias.md#aliaspath-and-aliaschoices)
 |
 |  A data class used by `validation_alias` as a convenience to create aliases.
 |
 |  Attributes:
 |      choices: A list containing a string or `AliasPath`.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, first_choice: 'str | AliasPath', *choices: 'str | AliasPath') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  convert_to_aliases(self) -> 'list[list[str | int]]'
 |      Converts arguments to a list of lists containing string or integer aliases.
 |
 |      Returns:
 |          The list of aliases.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  choices
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'choices': 'list[str | AliasPath]'}
 |
 |  __dataclass_fields__ = {'choices': Field(name='choices',type='list[str...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('choices',)

Python Library Documentation: class AliasGenerator in module pydantic.aliases

class AliasGenerator(builtins.object)
 |  AliasGenerator(alias: 'Callable[[str], str] | None' = None, validation_alias: 'Callable[[str], str | AliasPath | AliasChoices] | None' = None, serialization_alias: 'Callable[[str], str] | None' = None) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [Using an `AliasGenerator`](../concepts/alias.md#using-an-aliasgenerator)
 |
 |  A data class used by `alias_generator` as a convenience to create various aliases.
 |
 |  Attributes:
 |      alias: A callable that takes a field name and returns an alias for it.
 |      validation_alias: A callable that takes a field name and returns a validation alias for it.
 |      serialization_alias: A callable that takes a field name and returns a serialization alias for it.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, alias: 'Callable[[str], str] | None' = None, validation_alias: 'Callable[[str], str | AliasPath | AliasChoices] | None' = None, serialization_alias: 'Callable[[str], str] | None' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  generate_aliases(self, field_name: 'str') -> 'tuple[str | None, str | AliasPath | AliasChoices | None, str | None]'
 |      Generate `alias`, `validation_alias`, and `serialization_alias` for a field.
 |
 |      Returns:
 |          A tuple of three aliases - validation, alias, and serialization.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  alias
 |
 |  serialization_alias
 |
 |  validation_alias
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'alias': 'Callable[[str], str] | None', 'serializat...
 |
 |  __dataclass_fields__ = {'alias': Field(name='alias',type='Callable[[st...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('alias', 'validation_alias', 'serialization_alias')

Python Library Documentation: class AliasPath in module pydantic.aliases

class AliasPath(builtins.object)
 |  AliasPath(first_arg: 'str', *args: 'str | int') -> 'None'
 |
 |  !!! abstract "Usage Documentation"
 |      [`AliasPath` and `AliasChoices`](../concepts/alias.md#aliaspath-and-aliaschoices)
 |
 |  A data class used by `validation_alias` as a convenience to create aliases.
 |
 |  Attributes:
 |      path: A list of string or integer aliases.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, first_arg: 'str', *args: 'str | int') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  convert_to_aliases(self) -> 'list[str | int]'
 |      Converts arguments to a list of string or integer aliases.
 |
 |      Returns:
 |          The list of aliases.
 |
 |  search_dict_for_path(self, d: 'dict') -> 'Any'
 |      Searches a dictionary for the path specified by the alias.
 |
 |      Returns:
 |          The value at the specified path, or `PydanticUndefined` if the path is not found.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  path
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'path': 'list[int | str]'}
 |
 |  __dataclass_fields__ = {'path': Field(name='path',type='list[int | str...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('path',)

Python Library Documentation: class AllowInfNan in module pydantic.types

class AllowInfNan(pydantic._internal._fields.PydanticMetadata)
 |  AllowInfNan(allow_inf_nan: 'bool' = True) -> None
 |
 |  A field metadata class to indicate that a field should allow `-inf`, `inf`, and `nan`.
 |
 |  Use this class as an annotation via [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated), as seen below.
 |
 |  Attributes:
 |      allow_inf_nan: Whether to allow `-inf`, `inf`, and `nan`. Defaults to `True`.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic.types import AllowInfNan
 |
 |      LaxFloat = Annotated[float, AllowInfNan()]
 |      ```
 |
 |  Method resolution order:
 |      AllowInfNan
 |      pydantic._internal._fields.PydanticMetadata
 |      pydantic._internal._repr.Representation
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, allow_inf_nan: 'bool' = True) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'allow_inf_nan': 'bool'}
 |
 |  __dataclass_fields__ = {'allow_inf_nan': Field(name='allow_inf_nan',ty...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('allow_inf_nan',)
 |
 |  allow_inf_nan = True
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic._internal._repr.Representation:
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __repr_args__(self) -> 'ReprArgs'
 |      Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
 |
 |      Can either return:
 |      * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
 |      * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
 |
 |  __repr_name__(self) -> 'str'
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str'
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str'
 |
 |  __rich_repr__(self) -> 'RichReprResult'
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).

Python Library Documentation: class AmqpDsn in module pydantic.networks

class AmqpDsn(AnyUrl)
 |  AmqpDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any AMQP DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      AmqpDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class AnyHttpUrl in module pydantic.networks

class AnyHttpUrl(AnyUrl)
 |  AnyHttpUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any http or https URL.
 |
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      AnyHttpUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class AnyUrl in module pydantic.networks

class AnyUrl(_BaseUrl)
 |  AnyUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  Base type for all URLs.
 |
 |  * Any scheme allowed
 |  * Top-level domain (TLD) not required
 |  * Host not required
 |
 |  Assuming an input URL of `http://samuel:pass@example.com:8000/the/path/?query=here#fragment=is;this=bit`,
 |  the types export the following properties:
 |
 |  - `scheme`: the URL scheme (`http`), always set.
 |  - `host`: the URL host (`example.com`).
 |  - `username`: optional username if included (`samuel`).
 |  - `password`: optional password if included (`pass`).
 |  - `port`: optional port (`8000`).
 |  - `path`: optional path (`/the/path/`).
 |  - `query`: optional URL query (for example, `GET` arguments or "search string", such as `query=here`).
 |  - `fragment`: optional fragment (`fragment=is;this=bit`).
 |
 |  Method resolution order:
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class AnyWebsocketUrl in module pydantic.networks

class AnyWebsocketUrl(AnyUrl)
 |  AnyWebsocketUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any ws or wss URL.
 |
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      AnyWebsocketUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class AwareDatetime in module pydantic.types

class AwareDatetime(builtins.object)
 |  A datetime that requires timezone info.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __buffer__(self, flags, /)
 |      Return a buffer object that exposes the underlying memory of the object.
 |
 |  __bytes__(self, /)
 |      Convert this value to exact type bytes.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |
 |  center(self, width, fillchar=b' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  hex(...)
 |      Create a string of hexadecimal numbers from a bytes object.
 |
 |        sep
 |          An optional single character or byte to separate hex bytes.
 |        bytes_per_sep
 |          How many bytes between separators.  Positive values count from the
 |          right, negative values count from the left.
 |
 |      Example:
 |      >>> value = b'\xb9\x01\xef'
 |      >>> value.hex()
 |      'b901ef'
 |      >>> value.hex(':')
 |      'b9:01:ef'
 |      >>> value.hex(':', 2)
 |      'b9:01ef'
 |      >>> value.hex(':', -2)
 |      'b901:ef'
 |
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the subsection is not found.
 |
 |  isalnum(...)
 |      B.isalnum() -> bool
 |
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |
 |  isalpha(...)
 |      B.isalpha() -> bool
 |
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |
 |  isascii(...)
 |      B.isascii() -> bool
 |
 |      Return True if B is empty or all characters in B are ASCII,
 |      False otherwise.
 |
 |  isdigit(...)
 |      B.isdigit() -> bool
 |
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |
 |  islower(...)
 |      B.islower() -> bool
 |
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  isspace(...)
 |      B.isspace() -> bool
 |
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |
 |  istitle(...)
 |      B.istitle() -> bool
 |
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |
 |  isupper(...)
 |      B.isupper() -> bool
 |
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |
 |      The bytes whose method is called is inserted in between each pair.
 |
 |      The result is returned as a new bytes object.
 |
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |
 |  ljust(self, width, fillchar=b' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  lower(...)
 |      B.lower() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |
 |  removeprefix(self, prefix, /)
 |      Return a bytes object with the given prefix string removed if present.
 |
 |      If the bytes starts with the prefix string, return bytes[len(prefix):].
 |      Otherwise, return a copy of the original bytes.
 |
 |  removesuffix(self, suffix, /)
 |      Return a bytes object with the given suffix string removed if present.
 |
 |      If the bytes ends with the suffix string and that suffix is not empty,
 |      return bytes[:-len(prefix)].  Otherwise, return a copy of the original
 |      bytes.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raise ValueError when the subsection is not found.
 |
 |  rjust(self, width, fillchar=b' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |
 |      Splitting is done starting at the end of the bytes and working to the front.
 |
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |
 |  title(...)
 |      B.title() -> copy of B
 |
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |
 |  upper(...)
 |      B.upper() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The original string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  fromhex(string, /)
 |      Create a bytes object from a string of hexadecimal numbers.
 |
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |
 |      The bytes objects frm and to must be of the same length.

Python Library Documentation: class Base64Encoder in module pydantic.types

class Base64Encoder(EncoderProtocol)
 |  Base64Encoder(*args, **kwargs)
 |
 |  Standard (non-URL-safe) Base64 encoder.
 |
 |  Method resolution order:
 |      Base64Encoder
 |      EncoderProtocol
 |      typing_extensions.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing_extensions
 |
 |  decode(data: 'bytes') -> 'bytes'
 |      Decode the data from base64 encoded bytes to original bytes data.
 |
 |      Args:
 |          data: The data to decode.
 |
 |      Returns:
 |          The decoded data.
 |
 |  encode(value: 'bytes') -> 'bytes'
 |      Encode the data from bytes to a base64 encoded bytes.
 |
 |      Args:
 |          value: The data to encode.
 |
 |      Returns:
 |          The encoded data.
 |
 |  get_json_format() -> "Literal['base64']"
 |      Get the JSON format for the encoded data.
 |
 |      Returns:
 |          The JSON format for the encoded data.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from EncoderProtocol:
 |
 |  __init__ = _no_init(self, *args, **kwargs) from typing_extensions
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from EncoderProtocol:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from EncoderProtocol:
 |
 |  __protocol_attrs__ = {'decode', 'encode', 'get_json_format'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing_extensions.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the end of the string and works to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the front of the string and works to the end.
 |
 |      Note, str.split() is mainly useful for data that has been intentionally
 |      delimited.  With natural text that includes punctuation, consider using
 |      the regular expression module.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(...)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __buffer__(self, flags, /)
 |      Return a buffer object that exposes the underlying memory of the object.
 |
 |  __bytes__(self, /)
 |      Convert this value to exact type bytes.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |
 |  center(self, width, fillchar=b' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  hex(...)
 |      Create a string of hexadecimal numbers from a bytes object.
 |
 |        sep
 |          An optional single character or byte to separate hex bytes.
 |        bytes_per_sep
 |          How many bytes between separators.  Positive values count from the
 |          right, negative values count from the left.
 |
 |      Example:
 |      >>> value = b'\xb9\x01\xef'
 |      >>> value.hex()
 |      'b901ef'
 |      >>> value.hex(':')
 |      'b9:01:ef'
 |      >>> value.hex(':', 2)
 |      'b9:01ef'
 |      >>> value.hex(':', -2)
 |      'b901:ef'
 |
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the subsection is not found.
 |
 |  isalnum(...)
 |      B.isalnum() -> bool
 |
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |
 |  isalpha(...)
 |      B.isalpha() -> bool
 |
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |
 |  isascii(...)
 |      B.isascii() -> bool
 |
 |      Return True if B is empty or all characters in B are ASCII,
 |      False otherwise.
 |
 |  isdigit(...)
 |      B.isdigit() -> bool
 |
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |
 |  islower(...)
 |      B.islower() -> bool
 |
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  isspace(...)
 |      B.isspace() -> bool
 |
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |
 |  istitle(...)
 |      B.istitle() -> bool
 |
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |
 |  isupper(...)
 |      B.isupper() -> bool
 |
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |
 |      The bytes whose method is called is inserted in between each pair.
 |
 |      The result is returned as a new bytes object.
 |
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |
 |  ljust(self, width, fillchar=b' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  lower(...)
 |      B.lower() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |
 |  removeprefix(self, prefix, /)
 |      Return a bytes object with the given prefix string removed if present.
 |
 |      If the bytes starts with the prefix string, return bytes[len(prefix):].
 |      Otherwise, return a copy of the original bytes.
 |
 |  removesuffix(self, suffix, /)
 |      Return a bytes object with the given suffix string removed if present.
 |
 |      If the bytes ends with the suffix string and that suffix is not empty,
 |      return bytes[:-len(prefix)].  Otherwise, return a copy of the original
 |      bytes.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raise ValueError when the subsection is not found.
 |
 |  rjust(self, width, fillchar=b' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |
 |      Splitting is done starting at the end of the bytes and working to the front.
 |
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |
 |  title(...)
 |      B.title() -> copy of B
 |
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |
 |  upper(...)
 |      B.upper() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The original string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  fromhex(string, /)
 |      Create a bytes object from a string of hexadecimal numbers.
 |
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |
 |      The bytes objects frm and to must be of the same length.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the end of the string and works to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the front of the string and works to the end.
 |
 |      Note, str.split() is mainly useful for data that has been intentionally
 |      delimited.  With natural text that includes punctuation, consider using
 |      the regular expression module.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(...)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

Python Library Documentation: class BaseConfig in module pydantic.deprecated.config

class BaseConfig(builtins.object)
 |  BaseConfig(*args, **kwargs)
 |
 |  This class is only retained for backwards compatibility.
 |
 |  !!! Warning "Deprecated"
 |      BaseConfig is deprecated. Use the [`pydantic.ConfigDict`][pydantic.ConfigDict] instead.
 |
 |  Methods defined here:
 |
 |  __getattr__(self, item: 'str') -> 'Any'
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __init_subclass__(**kwargs: 'Any') -> 'None'
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from object
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __deprecated__ = 'BaseConfig is deprecated. Use the `pydantic.ConfigDi...

Python Library Documentation: class BaseModel in module pydantic.main

class BaseModel(builtins.object)
 |  BaseModel(**data: 'Any') -> 'None'
 |
 |  !!! abstract "Usage Documentation"
 |      [Models](../concepts/models.md)
 |
 |  A base class for creating Pydantic models.
 |
 |  Attributes:
 |      __class_vars__: The names of the class variables defined on the model.
 |      __private_attributes__: Metadata about the private attributes of the model.
 |      __signature__: The synthesized `__init__` [`Signature`][inspect.Signature] of the model.
 |
 |      __pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
 |      __pydantic_core_schema__: The core schema of the model.
 |      __pydantic_custom_init__: Whether the model has a custom `__init__` function.
 |      __pydantic_decorators__: Metadata containing the decorators defined on the model.
 |          This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
 |      __pydantic_generic_metadata__: A dictionary containing metadata about generic Pydantic models.
 |          The `origin` and `args` items map to the [`__origin__`][genericalias.__origin__]
 |          and [`__args__`][genericalias.__args__] attributes of [generic aliases][types-genericalias],
 |          and the `parameter` item maps to the `__parameter__` attribute of generic classes.
 |      __pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
 |      __pydantic_post_init__: The name of the post-init method for the model, if defined.
 |      __pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
 |      __pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
 |      __pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
 |
 |      __pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
 |      __pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
 |
 |      __pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
 |          is set to `'allow'`.
 |      __pydantic_fields_set__: The names of fields explicitly set during instantiation.
 |      __pydantic_private__: Values of private attributes set on the model instance.
 |
 |  Methods defined here:
 |
 |  __copy__(self) -> 'Self'
 |      Returns a shallow copy of the model.
 |
 |  __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
 |      Returns a deep copy of the model.
 |
 |  __delattr__(self, item: 'str') -> 'Any'
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __getattr__(self, item: 'str') -> 'Any'
 |
 |  __getstate__(self) -> 'dict[Any, Any]'
 |      Helper for pickle.
 |
 |  __init__(self, /, **data: 'Any') -> 'None'
 |      Create a new model by parsing and validating input data from keyword arguments.
 |
 |      Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
 |      validated to form a valid model.
 |
 |      `self` is explicitly positional-only to allow `self` as a field name.
 |
 |  __iter__(self) -> 'TupleGenerator'
 |      So `dict(model)` works.
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __replace__(self, **changes: 'Any') -> 'Self'
 |      # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
 |      # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __repr_args__(self) -> '_repr.ReprArgs'
 |
 |  __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
 |
 |  __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
 |
 |  __setattr__(self, name: 'str', value: 'Any') -> 'None'
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state: 'dict[Any, Any]') -> 'None'
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
 |      Returns a copy of the model.
 |
 |      !!! warning "Deprecated"
 |          This method is now deprecated; use `model_copy` instead.
 |
 |      If you need `include` or `exclude`, use:
 |
 |      ```python {test="skip" lint="skip"}
 |      data = self.model_dump(include=include, exclude=exclude, round_trip=True)
 |      data = {**data, **(update or {})}
 |      copied = self.model_validate(data)
 |      ```
 |
 |      Args:
 |          include: Optional set or mapping specifying which fields to include in the copied model.
 |          exclude: Optional set or mapping specifying which fields to exclude in the copied model.
 |          update: Optional dictionary of field-value pairs to override field values in the copied model.
 |          deep: If True, the values of fields that are Pydantic models will be deep-copied.
 |
 |      Returns:
 |          A copy of the model with included, excluded and updated fields as specified.
 |
 |  dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]'
 |
 |  json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
 |
 |  model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
 |      !!! abstract "Usage Documentation"
 |          [`model_copy`](../concepts/models.md#model-copy)
 |
 |      Returns a copy of the model.
 |
 |      !!! note
 |          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
 |          might have unexpected side effects if you store anything in it, on top of the model
 |          fields (e.g. the value of [cached properties][functools.cached_property]).
 |
 |      Args:
 |          update: Values to change/add in the new model. Note: the data is not validated
 |              before creating the new model. You should trust this data.
 |          deep: Set to `True` to make a deep copy of the model.
 |
 |      Returns:
 |          New model instance.
 |
 |  model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
 |      !!! abstract "Usage Documentation"
 |          [`model_dump`](../concepts/serialization.md#python-mode)
 |
 |      Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
 |
 |      Args:
 |          mode: The mode in which `to_python` should run.
 |              If mode is 'json', the output will only contain JSON serializable types.
 |              If mode is 'python', the output may contain non-JSON-serializable Python objects.
 |          include: A set of fields to include in the output.
 |          exclude: A set of fields to exclude from the output.
 |          context: Additional context to pass to the serializer.
 |          by_alias: Whether to use the field's alias in the dictionary key if defined.
 |          exclude_unset: Whether to exclude fields that have not been explicitly set.
 |          exclude_defaults: Whether to exclude fields that are set to their default value.
 |          exclude_none: Whether to exclude fields that have a value of `None`.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |
 |      Returns:
 |          A dictionary representation of the model.
 |
 |  model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
 |      !!! abstract "Usage Documentation"
 |          [`model_dump_json`](../concepts/serialization.md#json-mode)
 |
 |      Generates a JSON representation of the model using Pydantic's `to_json` method.
 |
 |      Args:
 |          indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
 |          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
 |              If `False` (the default), these characters will be output as-is.
 |          include: Field(s) to include in the JSON output.
 |          exclude: Field(s) to exclude from the JSON output.
 |          context: Additional context to pass to the serializer.
 |          by_alias: Whether to serialize using field aliases.
 |          exclude_unset: Whether to exclude fields that have not been explicitly set.
 |          exclude_defaults: Whether to exclude fields that are set to their default value.
 |          exclude_none: Whether to exclude fields that have a value of `None`.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |
 |      Returns:
 |          A JSON string representation of the model.
 |
 |  model_post_init(self, context: 'Any', /) -> 'None'
 |      Override this method to perform additional initialization after `__init__` and `model_construct`.
 |      This is useful if you want to do some validation that requires the entire model to be initialized.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
 |
 |  __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
 |      Hook into generating the model's JSON schema.
 |
 |      Args:
 |          core_schema: A `pydantic-core` CoreSchema.
 |              You can ignore this argument and call the handler with a new CoreSchema,
 |              wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
 |              or just call the handler with the original schema.
 |          handler: Call into Pydantic's internal JSON schema generation.
 |              This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
 |              generation fails.
 |              Since this gets called by `BaseModel.model_json_schema` you can override the
 |              `schema_generator` argument to that function to change JSON schema generation globally
 |              for a type.
 |
 |      Returns:
 |          A JSON schema, as a Python object.
 |
 |  __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
 |      This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
 |      only after basic class initialization is complete. In particular, attributes like `model_fields` will
 |      be present when this is called, but forward annotations are not guaranteed to be resolved yet,
 |      meaning that creating an instance of the class may fail.
 |
 |      This is necessary because `__init_subclass__` will always be called by `type.__new__`,
 |      and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
 |      `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
 |
 |      This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
 |      any kwargs passed to the class definition that aren't used internally by Pydantic.
 |
 |      Args:
 |          **kwargs: Any keyword arguments passed to the class definition that aren't used internally
 |              by Pydantic.
 |
 |      Note:
 |          You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
 |          instead, which is called once the class and its fields are fully initialized and ready for validation.
 |
 |  __pydantic_on_complete__() -> 'None'
 |      This is called once the class and its fields are fully initialized and ready to be used.
 |
 |      This typically happens when the class is created (just before
 |      [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
 |      except when forward annotations are used that could not immediately be resolved.
 |      In that case, it will be called later, when the model is rebuilt automatically or explicitly using
 |      [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
 |
 |  construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
 |
 |  from_orm(obj: 'Any') -> 'Self'
 |
 |  model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
 |      Creates a new instance of the `Model` class with validated data.
 |
 |      Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
 |      Default values are respected, but no other validation is performed.
 |
 |      !!! note
 |          `model_construct()` generally respects the `model_config.extra` setting on the provided model.
 |          That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
 |          and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
 |          Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
 |          an error if extra values are passed, but they will be ignored.
 |
 |      Args:
 |          _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
 |              this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
 |              Otherwise, the field names from the `values` argument will be used.
 |          values: Trusted or pre-validated data dictionary.
 |
 |      Returns:
 |          A new instance of the `Model` class with validated data.
 |
 |  model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
 |      Generates a JSON schema for a model class.
 |
 |      Args:
 |          by_alias: Whether to use attribute aliases or not.
 |          ref_template: The reference template.
 |          union_format: The format to use when combining schemas from unions together. Can be one of:
 |
 |              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
 |              keyword to combine schemas (the default).
 |              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
 |              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
 |              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
 |              `any_of`.
 |          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
 |              `GenerateJsonSchema` with your desired modifications
 |          mode: The mode in which to generate the schema.
 |
 |      Returns:
 |          The JSON schema for the given model class.
 |
 |  model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
 |      Compute the class name for parametrizations of generic classes.
 |
 |      This method can be overridden to achieve a custom naming scheme for generic BaseModels.
 |
 |      Args:
 |          params: Tuple of types of the class. Given a generic class
 |              `Model` with 2 type variables and a concrete model `Model[str, int]`,
 |              the value `(str, int)` would be passed to `params`.
 |
 |      Returns:
 |          String representing the new class where `params` are passed to `cls` as type variables.
 |
 |      Raises:
 |          TypeError: Raised when trying to generate concrete names for non-generic models.
 |
 |  model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
 |      Try to rebuild the pydantic-core schema for the model.
 |
 |      This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
 |      the initial attempt to build the schema, and automatic rebuilding fails.
 |
 |      Args:
 |          force: Whether to force the rebuilding of the model schema, defaults to `False`.
 |          raise_errors: Whether to raise errors, defaults to `True`.
 |          _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
 |          _types_namespace: The types namespace, defaults to `None`.
 |
 |      Returns:
 |          Returns `None` if the schema is already "complete" and rebuilding was not required.
 |          If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
 |
 |  model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      Validate a pydantic model instance.
 |
 |      Args:
 |          obj: The object to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          from_attributes: Whether to extract data from object attributes.
 |          context: Additional context to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Raises:
 |          ValidationError: If the object could not be validated.
 |
 |      Returns:
 |          The validated model instance.
 |
 |  model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      !!! abstract "Usage Documentation"
 |          [JSON Parsing](../concepts/json.md#json-parsing)
 |
 |      Validate the given JSON data against the Pydantic model.
 |
 |      Args:
 |          json_data: The JSON data to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Extra variables to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated Pydantic model.
 |
 |      Raises:
 |          ValidationError: If `json_data` is not a JSON string or the object could not be validated.
 |
 |  model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      Validate the given object with string data against the Pydantic model.
 |
 |      Args:
 |          obj: The object containing string data to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Extra variables to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated Pydantic model.
 |
 |  parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
 |
 |  parse_obj(obj: 'Any') -> 'Self'
 |
 |  parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
 |
 |  schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
 |
 |  schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
 |
 |  update_forward_refs(**localns: 'Any') -> 'None'
 |
 |  validate(value: 'Any') -> 'Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  __fields_set__
 |
 |  model_extra
 |      Get extra fields set during validation.
 |
 |      Returns:
 |          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
 |
 |  model_fields_set
 |      Returns the set of fields that have been explicitly set on this model instance.
 |
 |      Returns:
 |          A set of strings representing the fields that have been set,
 |              i.e. that were not filled from defaults.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __pydantic_extra__
 |
 |  __pydantic_fields_set__
 |
 |  __pydantic_private__
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __hash__ = None
 |
 |  __pydantic_complete__ = False
 |
 |  __pydantic_core_schema__ = <pydantic._internal._mock_val_ser.MockCoreS...
 |
 |  __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
 |
 |  __pydantic_parent_namespace__ = None
 |
 |  __pydantic_root_model__ = False
 |
 |  __pydantic_serializer__ = <pydantic._internal._mock_val_ser.MockValSer...
 |
 |  __pydantic_validator__ = <pydantic._internal._mock_val_ser.MockValSer ...
 |
 |  model_computed_fields = {}
 |
 |  model_config = {}
 |
 |  model_fields = {}

Python Library Documentation: class BeforeValidator in module pydantic.functional_validators

class BeforeValidator(builtins.object)
 |  BeforeValidator(func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction', json_schema_input_type: 'Any' = PydanticUndefined) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [field *before* validators](../concepts/validators.md#field-before-validator)
 |
 |  A metadata class that indicates that a validation should be applied **before** the inner validation logic.
 |
 |  Attributes:
 |      func: The validator function.
 |      json_schema_input_type: The input type used to generate the appropriate
 |          JSON Schema (in validation mode). The actual input type is `Any`.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic import BaseModel, BeforeValidator
 |
 |      MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)]
 |
 |      class Model(BaseModel):
 |          a: MyInt
 |
 |      print(Model(a=1).a)
 |      #> 2
 |
 |      try:
 |          Model(a='a')
 |      except TypeError as e:
 |          print(e)
 |          #> can only concatenate str (not "int") to str
 |      ```
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction', json_schema_input_type: 'Any' = PydanticUndefined) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  json_schema_input_type
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.NoInfoValidatorFunction | core...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.No...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func', 'json_schema_input_type')

Python Library Documentation: class ByteSize in module pydantic.types

class ByteSize(builtins.int)
 |  Converts a string representing a number of bytes with units (such as `'1KB'` or `'11.5MiB'`) into an integer.
 |
 |  You can use the `ByteSize` data type to (case-insensitively) convert a string representation of a number of bytes into
 |  an integer, and also to print out human-readable strings representing a number of bytes.
 |
 |  In conformance with [IEC 80000-13 Standard](https://en.wikipedia.org/wiki/ISO/IEC_80000) we interpret `'1KB'` to mean 1000 bytes,
 |  and `'1KiB'` to mean 1024 bytes. In general, including a middle `'i'` will cause the unit to be interpreted as a power of 2,
 |  rather than a power of 10 (so, for example, `'1 MB'` is treated as `1_000_000` bytes, whereas `'1 MiB'` is treated as `1_048_576` bytes).
 |
 |  !!! info
 |      Note that `1b` will be parsed as "1 byte" and not "1 bit".
 |
 |  ```python
 |  from pydantic import BaseModel, ByteSize
 |
 |  class MyModel(BaseModel):
 |      size: ByteSize
 |
 |  print(MyModel(size=52000).size)
 |  #> 52000
 |  print(MyModel(size='3000 KiB').size)
 |  #> 3072000
 |
 |  m = MyModel(size='50 PB')
 |  print(m.size.human_readable())
 |  #> 44.4PiB
 |  print(m.size.human_readable(decimal=True))
 |  #> 50.0PB
 |  print(m.size.human_readable(separator=' '))
 |  #> 44.4 PiB
 |
 |  print(m.size.to('TiB'))
 |  #> 45474.73508864641
 |  ```
 |
 |  Method resolution order:
 |      ByteSize
 |      builtins.int
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  human_readable(self, decimal: 'bool' = False, separator: 'str' = '') -> 'str'
 |      Converts a byte size to a human readable string.
 |
 |      Args:
 |          decimal: If True, use decimal units (e.g. 1000 bytes per KB). If False, use binary units
 |              (e.g. 1024 bytes per KiB).
 |          separator: A string used to split the value and unit. Defaults to an empty string ('').
 |
 |      Returns:
 |          A human readable string representation of the byte size.
 |
 |  to(self, unit: 'str') -> 'float'
 |      Converts a byte size to another unit, including both byte and bit units.
 |
 |      Args:
 |          unit: The unit to convert to. Must be one of the following: B, KB, MB, GB, TB, PB, EB,
 |              KiB, MiB, GiB, TiB, PiB, EiB (byte units) and
 |              bit, kbit, mbit, gbit, tbit, pbit, ebit,
 |              kibit, mibit, gibit, tibit, pibit, eibit (bit units).
 |
 |      Returns:
 |          The byte size in the new unit.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  byte_sizes = {'b': 1, 'bit': 0.125, 'e': 1000000000000000000, 'eb': 10...
 |
 |  byte_string_pattern = r'^\s*(\d*\.?\d+)\s*(\w+)?'
 |
 |  byte_string_re = re.compile('^\\s*(\\d*\\.?\\d+)\\s*(\\w+)?', re.IGNOR...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from builtins.int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.int:
 |
 |  __new__(*args, **kwargs) class method of builtins.int
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.int:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: class ClickHouseDsn in module pydantic.networks

class ClickHouseDsn(AnyUrl)
 |  ClickHouseDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any ClickHouse DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      ClickHouseDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class CockroachDsn in module pydantic.networks

class CockroachDsn(AnyUrl)
 |  CockroachDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any Cockroach DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host required
 |
 |  Method resolution order:
 |      CockroachDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Readonly properties defined here:
 |
 |  host
 |      The required URL host.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class ConfigDict in module pydantic.config

class ConfigDict(builtins.dict)
 |  A TypedDict for configuring Pydantic behaviour.
 |
 |  Method resolution order:
 |      ConfigDict
 |      builtins.dict
 |      builtins.object
 |
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'alias_generator': ForwardRef('Callable[[str], str]...
 |
 |  __closed__ = None
 |
 |  __extra_items__ = typing_extensions.NoExtraItems
 |
 |  __mutable_keys__ = frozenset({'alias_generator', 'allow_inf_nan', 'arb...
 |
 |  __optional_keys__ = frozenset({'alias_generator', 'allow_inf_nan', 'ar...
 |
 |  __orig_bases__ = (typing_extensions.TypedDict,)
 |
 |  __readonly_keys__ = frozenset()
 |
 |  __required_keys__ = frozenset()
 |
 |  __total__ = False
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.dict:
 |
 |  __contains__(self, key, /)
 |      True if the dictionary has the specified key, else False.
 |
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __ior__(self, value, /)
 |      Return self|=value.
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __reversed__(self, /)
 |      Return a reverse iterator over the dict keys.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |
 |      If the key is not found, return the default if given; otherwise,
 |      raise a KeyError.
 |
 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |
 |      Return the value for key if key is in the dictionary, else default.
 |
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from builtins.dict:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  fromkeys(iterable, value=None, /)
 |      Create a new dictionary with keys from iterable and values set to value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.dict:
 |
 |  __new__(*args, **kwargs) class method of builtins.dict
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from builtins.dict:
 |
 |  __hash__ = None

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class Path(PurePath)
 |  Annotated(*args, **kwargs)
 |
 |  PurePath subclass that can make system calls.
 |
 |  Path represents a filesystem path but unlike PurePath, also offers
 |  methods to do system calls on path objects. Depending on your system,
 |  instantiating a Path will return either a PosixPath or a WindowsPath
 |  object. You can also instantiate a PosixPath or WindowsPath directly,
 |  but cannot instantiate a WindowsPath on a POSIX system or vice versa.
 |
 |  Method resolution order:
 |      Path
 |      PurePath
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, t, v, tb)
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  absolute(self)
 |      Return an absolute version of this path by prepending the current
 |      working directory. No normalization or symlink resolution is performed.
 |
 |      Use resolve() to get the canonical path to a file.
 |
 |  chmod(self, mode, *, follow_symlinks=True)
 |      Change the permissions of the path, like os.chmod().
 |
 |  exists(self, *, follow_symlinks=True)
 |      Whether this path exists.
 |
 |      This method normally follows symlinks; to check whether a symlink exists,
 |      add the argument follow_symlinks=False.
 |
 |  expanduser(self)
 |      Return a new path with expanded ~ and ~user constructs
 |      (as returned by os.path.expanduser)
 |
 |  glob(self, pattern, *, case_sensitive=None)
 |      Iterate over this subtree and yield all existing files (of any
 |      kind, including directories) matching the given relative pattern.
 |
 |  group(self)
 |      Return the group name of the file gid.
 |
 |  hardlink_to(self, target)
 |      Make this path a hard link pointing to the same file as *target*.
 |
 |      Note the order of arguments (self, target) is the reverse of os.link's.
 |
 |  is_block_device(self)
 |      Whether this path is a block device.
 |
 |  is_char_device(self)
 |      Whether this path is a character device.
 |
 |  is_dir(self)
 |      Whether this path is a directory.
 |
 |  is_fifo(self)
 |      Whether this path is a FIFO.
 |
 |  is_file(self)
 |      Whether this path is a regular file (also True for symlinks pointing
 |      to regular files).
 |
 |  is_junction(self)
 |      Whether this path is a junction.
 |
 |  is_mount(self)
 |      Check if this path is a mount point
 |
 |  is_socket(self)
 |      Whether this path is a socket.
 |
 |  is_symlink(self)
 |      Whether this path is a symbolic link.
 |
 |  iterdir(self)
 |      Yield path objects of the directory contents.
 |
 |      The children are yielded in arbitrary order, and the
 |      special entries '.' and '..' are not included.
 |
 |  lchmod(self, mode)
 |      Like chmod(), except if the path points to a symlink, the symlink's
 |      permissions are changed, rather than its target's.
 |
 |  lstat(self)
 |      Like stat(), except if the path points to a symlink, the symlink's
 |      status information is returned, rather than its target's.
 |
 |  mkdir(self, mode=511, parents=False, exist_ok=False)
 |      Create a new directory at this given path.
 |
 |  open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
 |      Open the file pointed to by this path and return a file object, as
 |      the built-in open() function does.
 |
 |  owner(self)
 |      Return the login name of the file owner.
 |
 |  read_bytes(self)
 |      Open the file in bytes mode, read it, and close the file.
 |
 |  read_text(self, encoding=None, errors=None)
 |      Open the file in text mode, read it, and close the file.
 |
 |  readlink(self)
 |      Return the path to which the symbolic link points.
 |
 |  rename(self, target)
 |      Rename this path to the target path.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  replace(self, target)
 |      Rename this path to the target path, overwriting if that path exists.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  resolve(self, strict=False)
 |      Make the path absolute, resolving all symlinks on the way and also
 |      normalizing it.
 |
 |  rglob(self, pattern, *, case_sensitive=None)
 |      Recursively yield all existing files (of any kind, including
 |      directories) matching the given relative pattern, anywhere in
 |      this subtree.
 |
 |  rmdir(self)
 |      Remove this directory.  The directory must be empty.
 |
 |  samefile(self, other_path)
 |      Return whether other_path is the same or not as this file
 |      (as returned by os.path.samefile()).
 |
 |  stat(self, *, follow_symlinks=True)
 |      Return the result of the stat() system call on this path, like
 |      os.stat() does.
 |
 |  symlink_to(self, target, target_is_directory=False)
 |      Make this path a symlink pointing to the target path.
 |      Note the order of arguments (link, target) is the reverse of os.symlink.
 |
 |  touch(self, mode=438, exist_ok=True)
 |      Create this file with the given access mode, if it doesn't exist.
 |
 |  unlink(self, missing_ok=False)
 |      Remove this file or link.
 |      If the path is a directory, use rmdir() instead.
 |
 |  walk(self, top_down=True, on_error=None, follow_symlinks=False)
 |      Walk the directory tree from this directory, similar to os.walk().
 |
 |  write_bytes(self, data)
 |      Open the file in bytes mode, write to it, and close the file.
 |
 |  write_text(self, data, encoding=None, errors=None, newline=None)
 |      Open the file in text mode, write to it, and close the file.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  cwd()
 |      Return a new path pointing to the current working directory.
 |
 |  home()
 |      Return a new path pointing to the user's home directory (as
 |      returned by os.path.expanduser('~')).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, *args, **kwargs)
 |      Construct a PurePath from one or several strings and or existing
 |      PurePath objects.  The strings and path objects are combined so as
 |      to yield a canonicalized path, which is incorporated into the
 |      new PurePath object.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PurePath:
 |
 |  __bytes__(self)
 |      Return the bytes representation of the path.  This is only
 |      recommended to use under Unix.
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __fspath__(self)
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __rtruediv__(self, key)
 |
 |  __str__(self)
 |      Return the string representation of the path, suitable for
 |      passing to system calls.
 |
 |  __truediv__(self, key)
 |
 |  as_posix(self)
 |      Return the string representation of the path with forward (/)
 |      slashes.
 |
 |  as_uri(self)
 |      Return the path as a 'file' URI.
 |
 |  is_absolute(self)
 |      True if the path is absolute (has both a root and, if applicable,
 |      a drive).
 |
 |  is_relative_to(self, other, /, *_deprecated)
 |      Return True if the path is relative to another path or False.
 |
 |  is_reserved(self)
 |      Return True if the path contains one of the special names reserved
 |      by the system, if any.
 |
 |  joinpath(self, *pathsegments)
 |      Combine this path with one or several arguments, and return a
 |      new path representing either a subpath (if all arguments are relative
 |      paths) or a totally different path (if one of the arguments is
 |      anchored).
 |
 |  match(self, path_pattern, *, case_sensitive=None)
 |      Return True if this path matches the given pattern.
 |
 |  relative_to(self, other, /, *_deprecated, walk_up=False)
 |      Return the relative path to another path identified by the passed
 |      arguments.  If the operation is not possible (because this is not
 |      related to the other path), raise ValueError.
 |
 |      The *walk_up* parameter controls whether `..` may be used to resolve
 |      the path.
 |
 |  with_name(self, name)
 |      Return a new path with the file name changed.
 |
 |  with_segments(self, *pathsegments)
 |      Construct a new path object from any number of path-like objects.
 |      Subclasses may override this method to customize how new path objects
 |      are created from methods like `iterdir()`.
 |
 |  with_stem(self, stem)
 |      Return a new path with the stem changed.
 |
 |  with_suffix(self, suffix)
 |      Return a new path with the file suffix changed.  If the path
 |      has no suffix, add given suffix.  If the given suffix is an empty
 |      string, remove the suffix from the path.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from PurePath:
 |
 |  anchor
 |      The concatenation of the drive and root, or ''.
 |
 |  drive
 |      The drive prefix (letter or UNC path), if any.
 |
 |  name
 |      The final path component, if any.
 |
 |  parent
 |      The logical parent of the path.
 |
 |  parents
 |      A sequence of this path's logical parents.
 |
 |  parts
 |      An object providing sequence-like access to the
 |      components in the filesystem path.
 |
 |  root
 |      The root of the path, if any.
 |
 |  stem
 |      The final path component, minus its last suffix.
 |
 |  suffix
 |      The final component's last suffix, if any.
 |
 |      This includes the leading period. For example: '.txt'
 |
 |  suffixes
 |      A list of the final component's suffixes, if any.
 |
 |      These include the leading periods. For example: ['.tar', '.gz']

Python Library Documentation: class Discriminator in module pydantic.types

class Discriminator(builtins.object)
 |  Discriminator(discriminator: 'str | Callable[[Any], Hashable]', custom_error_type: 'str | None' = None, custom_error_message: 'str | None' = None, custom_error_context: 'dict[str, int | str | float] | None' = None) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [Discriminated Unions with `Callable` `Discriminator`](../concepts/unions.md#discriminated-unions-with-callable-discriminator)
 |
 |  Provides a way to use a custom callable as the way to extract the value of a union discriminator.
 |
 |  This allows you to get validation behavior like you'd get from `Field(discriminator=<field_name>)`,
 |  but without needing to have a single shared field across all the union choices. This also makes it
 |  possible to handle unions of models and primitive types with discriminated-union-style validation errors.
 |  Finally, this allows you to use a custom callable as the way to identify which member of a union a value
 |  belongs to, while still seeing all the performance benefits of a discriminated union.
 |
 |  Consider this example, which is much more performant with the use of `Discriminator` and thus a `TaggedUnion`
 |  than it would be as a normal `Union`.
 |
 |  ```python
 |  from typing import Annotated, Any, Literal, Union
 |
 |  from pydantic import BaseModel, Discriminator, Tag
 |
 |  class Pie(BaseModel):
 |      time_to_cook: int
 |      num_ingredients: int
 |
 |  class ApplePie(Pie):
 |      fruit: Literal['apple'] = 'apple'
 |
 |  class PumpkinPie(Pie):
 |      filling: Literal['pumpkin'] = 'pumpkin'
 |
 |  def get_discriminator_value(v: Any) -> str:
 |      if isinstance(v, dict):
 |          return v.get('fruit', v.get('filling'))
 |      return getattr(v, 'fruit', getattr(v, 'filling', None))
 |
 |  class ThanksgivingDinner(BaseModel):
 |      dessert: Annotated[
 |          Union[
 |              Annotated[ApplePie, Tag('apple')],
 |              Annotated[PumpkinPie, Tag('pumpkin')],
 |          ],
 |          Discriminator(get_discriminator_value),
 |      ]
 |
 |  apple_variation = ThanksgivingDinner.model_validate(
 |      {'dessert': {'fruit': 'apple', 'time_to_cook': 60, 'num_ingredients': 8}}
 |  )
 |  print(repr(apple_variation))
 |  '''
 |  ThanksgivingDinner(dessert=ApplePie(time_to_cook=60, num_ingredients=8, fruit='apple'))
 |  '''
 |
 |  pumpkin_variation = ThanksgivingDinner.model_validate(
 |      {
 |          'dessert': {
 |              'filling': 'pumpkin',
 |              'time_to_cook': 40,
 |              'num_ingredients': 6,
 |          }
 |      }
 |  )
 |  print(repr(pumpkin_variation))
 |  '''
 |  ThanksgivingDinner(dessert=PumpkinPie(time_to_cook=40, num_ingredients=6, filling='pumpkin'))
 |  '''
 |  ```
 |
 |  See the [Discriminated Unions] concepts docs for more details on how to use `Discriminator`s.
 |
 |  [Discriminated Unions]: ../concepts/unions.md#discriminated-unions
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, discriminator: 'str | Callable[[Any], Hashable]', custom_error_type: 'str | None' = None, custom_error_message: 'str | None' = None, custom_error_context: 'dict[str, int | str | float] | None' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  custom_error_context
 |
 |  custom_error_message
 |
 |  custom_error_type
 |
 |  discriminator
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'custom_error_context': 'dict[str, int | str | floa...
 |
 |  __dataclass_fields__ = {'custom_error_context': Field(name='custom_err...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('discriminator', 'custom_error_type', 'custom_error_...

Python Library Documentation: class EmailStr in module pydantic.networks

class EmailStr(builtins.object)
 |  Info:
 |      To use this type, you need to install the optional
 |      [`email-validator`](https://github.com/JoshData/python-email-validator) package:
 |
 |      ```bash
 |      pip install email-validator
 |      ```
 |
 |  Validate email addresses.
 |
 |  ```python
 |  from pydantic import BaseModel, EmailStr
 |
 |  class Model(BaseModel):
 |      email: EmailStr
 |
 |  print(Model(email='contact@mail.com'))
 |  #> email='contact@mail.com'
 |  ```
 |
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(_source: 'type[Any]', _handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class EncodedBytes in module pydantic.types

class EncodedBytes(builtins.object)
 |  EncodedBytes(encoder: 'type[EncoderProtocol]') -> None
 |
 |  A bytes type that is encoded and decoded using the specified encoder.
 |
 |  `EncodedBytes` needs an encoder that implements `EncoderProtocol` to operate.
 |
 |  ```python
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, EncodedBytes, EncoderProtocol, ValidationError
 |
 |  class MyEncoder(EncoderProtocol):
 |      @classmethod
 |      def decode(cls, data: bytes) -> bytes:
 |          if data == b'**undecodable**':
 |              raise ValueError('Cannot decode data')
 |          return data[13:]
 |
 |      @classmethod
 |      def encode(cls, value: bytes) -> bytes:
 |          return b'**encoded**: ' + value
 |
 |      @classmethod
 |      def get_json_format(cls) -> str:
 |          return 'my-encoder'
 |
 |  MyEncodedBytes = Annotated[bytes, EncodedBytes(encoder=MyEncoder)]
 |
 |  class Model(BaseModel):
 |      my_encoded_bytes: MyEncodedBytes
 |
 |  # Initialize the model with encoded data
 |  m = Model(my_encoded_bytes=b'**encoded**: some bytes')
 |
 |  # Access decoded value
 |  print(m.my_encoded_bytes)
 |  #> b'some bytes'
 |
 |  # Serialize into the encoded form
 |  print(m.model_dump())
 |  #> {'my_encoded_bytes': b'**encoded**: some bytes'}
 |
 |  # Validate encoded data
 |  try:
 |      Model(my_encoded_bytes=b'**undecodable**')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for Model
 |      my_encoded_bytes
 |        Value error, Cannot decode data [type=value_error, input_value=b'**undecodable**', input_type=bytes]
 |      '''
 |  ```
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(self, core_schema: 'core_schema.CoreSchema', handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, encoder: 'type[EncoderProtocol]') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  decode(self, data: 'bytes', _: 'core_schema.ValidationInfo') -> 'bytes'
 |      Decode the data using the specified encoder.
 |
 |      Args:
 |          data: The data to decode.
 |
 |      Returns:
 |          The decoded data.
 |
 |  encode(self, value: 'bytes') -> 'bytes'
 |      Encode the data using the specified encoder.
 |
 |      Args:
 |          value: The data to encode.
 |
 |      Returns:
 |          The encoded data.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  encoder
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'encoder': 'type[EncoderProtocol]'}
 |
 |  __dataclass_fields__ = {'encoder': Field(name='encoder',type='type[Enc...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('encoder',)

Python Library Documentation: class EncodedStr in module pydantic.types

class EncodedStr(builtins.object)
 |  EncodedStr(encoder: 'type[EncoderProtocol]') -> None
 |
 |  A str type that is encoded and decoded using the specified encoder.
 |
 |  `EncodedStr` needs an encoder that implements `EncoderProtocol` to operate.
 |
 |  ```python
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, EncodedStr, EncoderProtocol, ValidationError
 |
 |  class MyEncoder(EncoderProtocol):
 |      @classmethod
 |      def decode(cls, data: bytes) -> bytes:
 |          if data == b'**undecodable**':
 |              raise ValueError('Cannot decode data')
 |          return data[13:]
 |
 |      @classmethod
 |      def encode(cls, value: bytes) -> bytes:
 |          return b'**encoded**: ' + value
 |
 |      @classmethod
 |      def get_json_format(cls) -> str:
 |          return 'my-encoder'
 |
 |  MyEncodedStr = Annotated[str, EncodedStr(encoder=MyEncoder)]
 |
 |  class Model(BaseModel):
 |      my_encoded_str: MyEncodedStr
 |
 |  # Initialize the model with encoded data
 |  m = Model(my_encoded_str='**encoded**: some str')
 |
 |  # Access decoded value
 |  print(m.my_encoded_str)
 |  #> some str
 |
 |  # Serialize into the encoded form
 |  print(m.model_dump())
 |  #> {'my_encoded_str': '**encoded**: some str'}
 |
 |  # Validate encoded data
 |  try:
 |      Model(my_encoded_str='**undecodable**')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for Model
 |      my_encoded_str
 |        Value error, Cannot decode data [type=value_error, input_value='**undecodable**', input_type=str]
 |      '''
 |  ```
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(self, core_schema: 'core_schema.CoreSchema', handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, encoder: 'type[EncoderProtocol]') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  decode_str(self, data: 'str', _: 'core_schema.ValidationInfo') -> 'str'
 |      Decode the data using the specified encoder.
 |
 |      Args:
 |          data: The data to decode.
 |
 |      Returns:
 |          The decoded data.
 |
 |  encode_str(self, value: 'str') -> 'str'
 |      Encode the data using the specified encoder.
 |
 |      Args:
 |          value: The data to encode.
 |
 |      Returns:
 |          The encoded data.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  encoder
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'encoder': 'type[EncoderProtocol]'}
 |
 |  __dataclass_fields__ = {'encoder': Field(name='encoder',type='type[Enc...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('encoder',)

Python Library Documentation: class EncoderProtocol in module pydantic.types

class EncoderProtocol(typing_extensions.Protocol)
 |  EncoderProtocol(*args, **kwargs)
 |
 |  Protocol for encoding and decoding data to and from bytes.
 |
 |  Method resolution order:
 |      EncoderProtocol
 |      typing_extensions.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = _no_init(self, *args, **kwargs) from typing_extensions
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing_extensions
 |
 |  decode(data: 'bytes') -> 'bytes'
 |      Decode the data using the encoder.
 |
 |      Args:
 |          data: The data to decode.
 |
 |      Returns:
 |          The decoded data.
 |
 |  encode(value: 'bytes') -> 'bytes'
 |      Encode the data using the encoder.
 |
 |      Args:
 |          value: The data to encode.
 |
 |      Returns:
 |          The encoded data.
 |
 |  get_json_format() -> 'str'
 |      Get the JSON format for the encoded data.
 |
 |      Returns:
 |          The JSON format for the encoded data.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __parameters__ = ()
 |
 |  __protocol_attrs__ = {'decode', 'encode', 'get_json_format'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing_extensions.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class Extra in module pydantic.deprecated.config

class Extra(builtins.object)
 |  Extra(*args, **kwargs)
 |
 |  Class methods defined here:
 |
 |  __init_subclass__(*args, **kwargs) from typing_extensions.deprecated.__call__.<locals>
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from object
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'allow': "Literal['allow']", 'forbid': "Literal['fo...
 |
 |  __deprecated__ = "Extra is deprecated. Use literal values instead (e.g...
 |
 |  allow = 'allow'
 |
 |  forbid = 'forbid'
 |
 |  ignore = 'ignore'

Python Library Documentation: class FailFast in module pydantic.types

class FailFast(pydantic._internal._fields.PydanticMetadata, annotated_types.BaseMetadata)
 |  FailFast(fail_fast: 'bool' = True) -> None
 |
 |  A `FailFast` annotation can be used to specify that validation should stop at the first error.
 |
 |  This can be useful when you want to validate a large amount of data and you only need to know if it's valid or not.
 |
 |  You might want to enable this setting if you want to validate your data faster (basically, if you use this,
 |  validation will be more performant with the caveat that you get less information).
 |
 |  ```python
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, FailFast, ValidationError
 |
 |  class Model(BaseModel):
 |      x: Annotated[list[int], FailFast()]
 |
 |  # This will raise a single error for the first invalid value and stop validation
 |  try:
 |      obj = Model(x=[1, 2, 'a', 4, 5, 'b', 7, 8, 9, 'c'])
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for Model
 |      x.2
 |        Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
 |      '''
 |  ```
 |
 |  Method resolution order:
 |      FailFast
 |      pydantic._internal._fields.PydanticMetadata
 |      pydantic._internal._repr.Representation
 |      annotated_types.BaseMetadata
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, fail_fast: 'bool' = True) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'fail_fast': 'bool'}
 |
 |  __dataclass_fields__ = {'fail_fast': Field(name='fail_fast',type='bool...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('fail_fast',)
 |
 |  fail_fast = True
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic._internal._repr.Representation:
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __repr_args__(self) -> 'ReprArgs'
 |      Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
 |
 |      Can either return:
 |      * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
 |      * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
 |
 |  __repr_name__(self) -> 'str'
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str'
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str'
 |
 |  __rich_repr__(self) -> 'RichReprResult'
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).

Python Library Documentation: function Field in module pydantic.fields

Field(default: 'Any' = PydanticUndefined, *, default_factory: 'Callable[[], Any] | Callable[[dict[str, Any]], Any] | None' = PydanticUndefined, alias: 'str | None' = PydanticUndefined, alias_priority: 'int | None' = PydanticUndefined, validation_alias: 'str | AliasPath | AliasChoices | None' = PydanticUndefined, serialization_alias: 'str | None' = PydanticUndefined, title: 'str | None' = PydanticUndefined, field_title_generator: 'Callable[[str, FieldInfo], str] | None' = PydanticUndefined, description: 'str | None' = PydanticUndefined, examples: 'list[Any] | None' = PydanticUndefined, exclude: 'bool | None' = PydanticUndefined, exclude_if: 'Callable[[Any], bool] | None' = PydanticUndefined, discriminator: 'str | types.Discriminator | None' = PydanticUndefined, deprecated: 'Deprecated | str | bool | None' = PydanticUndefined, json_schema_extra: 'JsonDict | Callable[[JsonDict], None] | None' = PydanticUndefined, frozen: 'bool | None' = PydanticUndefined, validate_default: 'bool | None' = PydanticUndefined, repr: 'bool' = PydanticUndefined, init: 'bool | None' = PydanticUndefined, init_var: 'bool | None' = PydanticUndefined, kw_only: 'bool | None' = PydanticUndefined, pattern: 'str | re.Pattern[str] | None' = PydanticUndefined, strict: 'bool | None' = PydanticUndefined, coerce_numbers_to_str: 'bool | None' = PydanticUndefined, gt: 'annotated_types.SupportsGt | None' = PydanticUndefined, ge: 'annotated_types.SupportsGe | None' = PydanticUndefined, lt: 'annotated_types.SupportsLt | None' = PydanticUndefined, le: 'annotated_types.SupportsLe | None' = PydanticUndefined, multiple_of: 'float | None' = PydanticUndefined, allow_inf_nan: 'bool | None' = PydanticUndefined, max_digits: 'int | None' = PydanticUndefined, decimal_places: 'int | None' = PydanticUndefined, min_length: 'int | None' = PydanticUndefined, max_length: 'int | None' = PydanticUndefined, union_mode: "Literal['smart', 'left_to_right']" = PydanticUndefined, fail_fast: 'bool | None' = PydanticUndefined, **extra: 'Unpack[_EmptyKwargs]') -> 'Any'
    !!! abstract "Usage Documentation"
        [Fields](../concepts/fields.md)

    Create a field for objects that can be configured.

    Used to provide extra information about a field, either for the model schema or complex validation. Some arguments
    apply only to number fields (`int`, `float`, `Decimal`) and some apply only to `str`.

    Note:
        - Any `_Unset` objects will be replaced by the corresponding value defined in the `_DefaultValues` dictionary. If a key for the `_Unset` object is not found in the `_DefaultValues` dictionary, it will default to `None`

    Args:
        default: Default value if the field is not set.
        default_factory: A callable to generate the default value. The callable can either take 0 arguments
            (in which case it is called as is) or a single argument containing the already validated data.
        alias: The name to use for the attribute when validating or serializing by alias.
            This is often used for things like converting between snake and camel case.
        alias_priority: Priority of the alias. This affects whether an alias generator is used.
        validation_alias: Like `alias`, but only affects validation, not serialization.
        serialization_alias: Like `alias`, but only affects serialization, not validation.
        title: Human-readable title.
        field_title_generator: A callable that takes a field name and returns title for it.
        description: Human-readable description.
        examples: Example values for this field.
        exclude: Whether to exclude the field from the model serialization.
        exclude_if: A callable that determines whether to exclude a field during serialization based on its value.
        discriminator: Field name or Discriminator for discriminating the type in a tagged union.
        deprecated: A deprecation message, an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport,
            or a boolean. If `True`, a default deprecation message will be emitted when accessing the field.
        json_schema_extra: A dict or callable to provide extra JSON schema properties.
        frozen: Whether the field is frozen. If true, attempts to change the value on an instance will raise an error.
        validate_default: If `True`, apply validation to the default value every time you create an instance.
            Otherwise, for performance reasons, the default value of the field is trusted and not validated.
        repr: A boolean indicating whether to include the field in the `__repr__` output.
        init: Whether the field should be included in the constructor of the dataclass.
            (Only applies to dataclasses.)
        init_var: Whether the field should _only_ be included in the constructor of the dataclass.
            (Only applies to dataclasses.)
        kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass.
            (Only applies to dataclasses.)
        coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
        strict: If `True`, strict validation is applied to the field.
            See [Strict Mode](../concepts/strict_mode.md) for details.
        gt: Greater than. If set, value must be greater than this. Only applicable to numbers.
        ge: Greater than or equal. If set, value must be greater than or equal to this. Only applicable to numbers.
        lt: Less than. If set, value must be less than this. Only applicable to numbers.
        le: Less than or equal. If set, value must be less than or equal to this. Only applicable to numbers.
        multiple_of: Value must be a multiple of this. Only applicable to numbers.
        min_length: Minimum length for iterables.
        max_length: Maximum length for iterables.
        pattern: Pattern for strings (a regular expression).
        allow_inf_nan: Allow `inf`, `-inf`, `nan`. Only applicable to float and [`Decimal`][decimal.Decimal] numbers.
        max_digits: Maximum number of allow digits for strings.
        decimal_places: Maximum number of decimal places allowed for numbers.
        union_mode: The strategy to apply when validating a union. Can be `smart` (the default), or `left_to_right`.
            See [Union Mode](../concepts/unions.md#union-modes) for details.
        fail_fast: If `True`, validation will stop on the first error. If `False`, all validation errors will be collected.
            This option can be applied only to iterable types (list, tuple, set, and frozenset).
        extra: (Deprecated) Extra fields that will be included in the JSON schema.

            !!! warning Deprecated
                The `extra` kwargs is deprecated. Use `json_schema_extra` instead.

    Returns:
        A new [`FieldInfo`][pydantic.fields.FieldInfo]. The return annotation is `Any` so `Field` can be used on
            type-annotated fields without causing a type error.

Python Library Documentation: class FieldSerializationInfo in module pydantic_core.core_schema

class FieldSerializationInfo(SerializationInfo, typing.Protocol)
 |  FieldSerializationInfo(*args, **kwargs)
 |
 |  Extra data used during field serialization.
 |
 |  Method resolution order:
 |      FieldSerializationInfo
 |      SerializationInfo
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  field_name
 |      The name of the current field being serialized.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __orig_bases__ = (pydantic_core.core_schema.SerializationInfo[+Context...
 |
 |  __parameters__ = (+ContextT,)
 |
 |  __protocol_attrs__ = {'__repr__', '__str__', 'by_alias', 'context', 'e...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from SerializationInfo:
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  mode_is_json(self) -> 'bool'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from SerializationInfo:
 |
 |  by_alias
 |      The `by_alias` argument set during serialization.
 |
 |  context
 |      The current serialization context.
 |
 |  exclude
 |      The `exclude` argument set during serialization.
 |
 |  exclude_computed_fields
 |      The `exclude_computed_fields` argument set during serialization.
 |
 |  exclude_defaults
 |      The `exclude_defaults` argument set during serialization.
 |
 |  exclude_none
 |      The `exclude_none` argument set during serialization.
 |
 |  exclude_unset
 |      The `exclude_unset` argument set during serialization.
 |
 |  include
 |      The `include` argument set during serialization.
 |
 |  mode
 |      The serialization mode set during serialization.
 |
 |  polymorphic_serialization
 |      The `polymorphic_serialization` argument set during serialization, if any.
 |
 |  round_trip
 |      The `round_trip` argument set during serialization.
 |
 |  serialize_as_any
 |      The `serialize_as_any` argument set during serialization.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from SerializationInfo:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class Path(PurePath)
 |  Annotated(*args, **kwargs)
 |
 |  PurePath subclass that can make system calls.
 |
 |  Path represents a filesystem path but unlike PurePath, also offers
 |  methods to do system calls on path objects. Depending on your system,
 |  instantiating a Path will return either a PosixPath or a WindowsPath
 |  object. You can also instantiate a PosixPath or WindowsPath directly,
 |  but cannot instantiate a WindowsPath on a POSIX system or vice versa.
 |
 |  Method resolution order:
 |      Path
 |      PurePath
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, t, v, tb)
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  absolute(self)
 |      Return an absolute version of this path by prepending the current
 |      working directory. No normalization or symlink resolution is performed.
 |
 |      Use resolve() to get the canonical path to a file.
 |
 |  chmod(self, mode, *, follow_symlinks=True)
 |      Change the permissions of the path, like os.chmod().
 |
 |  exists(self, *, follow_symlinks=True)
 |      Whether this path exists.
 |
 |      This method normally follows symlinks; to check whether a symlink exists,
 |      add the argument follow_symlinks=False.
 |
 |  expanduser(self)
 |      Return a new path with expanded ~ and ~user constructs
 |      (as returned by os.path.expanduser)
 |
 |  glob(self, pattern, *, case_sensitive=None)
 |      Iterate over this subtree and yield all existing files (of any
 |      kind, including directories) matching the given relative pattern.
 |
 |  group(self)
 |      Return the group name of the file gid.
 |
 |  hardlink_to(self, target)
 |      Make this path a hard link pointing to the same file as *target*.
 |
 |      Note the order of arguments (self, target) is the reverse of os.link's.
 |
 |  is_block_device(self)
 |      Whether this path is a block device.
 |
 |  is_char_device(self)
 |      Whether this path is a character device.
 |
 |  is_dir(self)
 |      Whether this path is a directory.
 |
 |  is_fifo(self)
 |      Whether this path is a FIFO.
 |
 |  is_file(self)
 |      Whether this path is a regular file (also True for symlinks pointing
 |      to regular files).
 |
 |  is_junction(self)
 |      Whether this path is a junction.
 |
 |  is_mount(self)
 |      Check if this path is a mount point
 |
 |  is_socket(self)
 |      Whether this path is a socket.
 |
 |  is_symlink(self)
 |      Whether this path is a symbolic link.
 |
 |  iterdir(self)
 |      Yield path objects of the directory contents.
 |
 |      The children are yielded in arbitrary order, and the
 |      special entries '.' and '..' are not included.
 |
 |  lchmod(self, mode)
 |      Like chmod(), except if the path points to a symlink, the symlink's
 |      permissions are changed, rather than its target's.
 |
 |  lstat(self)
 |      Like stat(), except if the path points to a symlink, the symlink's
 |      status information is returned, rather than its target's.
 |
 |  mkdir(self, mode=511, parents=False, exist_ok=False)
 |      Create a new directory at this given path.
 |
 |  open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
 |      Open the file pointed to by this path and return a file object, as
 |      the built-in open() function does.
 |
 |  owner(self)
 |      Return the login name of the file owner.
 |
 |  read_bytes(self)
 |      Open the file in bytes mode, read it, and close the file.
 |
 |  read_text(self, encoding=None, errors=None)
 |      Open the file in text mode, read it, and close the file.
 |
 |  readlink(self)
 |      Return the path to which the symbolic link points.
 |
 |  rename(self, target)
 |      Rename this path to the target path.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  replace(self, target)
 |      Rename this path to the target path, overwriting if that path exists.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  resolve(self, strict=False)
 |      Make the path absolute, resolving all symlinks on the way and also
 |      normalizing it.
 |
 |  rglob(self, pattern, *, case_sensitive=None)
 |      Recursively yield all existing files (of any kind, including
 |      directories) matching the given relative pattern, anywhere in
 |      this subtree.
 |
 |  rmdir(self)
 |      Remove this directory.  The directory must be empty.
 |
 |  samefile(self, other_path)
 |      Return whether other_path is the same or not as this file
 |      (as returned by os.path.samefile()).
 |
 |  stat(self, *, follow_symlinks=True)
 |      Return the result of the stat() system call on this path, like
 |      os.stat() does.
 |
 |  symlink_to(self, target, target_is_directory=False)
 |      Make this path a symlink pointing to the target path.
 |      Note the order of arguments (link, target) is the reverse of os.symlink.
 |
 |  touch(self, mode=438, exist_ok=True)
 |      Create this file with the given access mode, if it doesn't exist.
 |
 |  unlink(self, missing_ok=False)
 |      Remove this file or link.
 |      If the path is a directory, use rmdir() instead.
 |
 |  walk(self, top_down=True, on_error=None, follow_symlinks=False)
 |      Walk the directory tree from this directory, similar to os.walk().
 |
 |  write_bytes(self, data)
 |      Open the file in bytes mode, write to it, and close the file.
 |
 |  write_text(self, data, encoding=None, errors=None, newline=None)
 |      Open the file in text mode, write to it, and close the file.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  cwd()
 |      Return a new path pointing to the current working directory.
 |
 |  home()
 |      Return a new path pointing to the user's home directory (as
 |      returned by os.path.expanduser('~')).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, *args, **kwargs)
 |      Construct a PurePath from one or several strings and or existing
 |      PurePath objects.  The strings and path objects are combined so as
 |      to yield a canonicalized path, which is incorporated into the
 |      new PurePath object.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PurePath:
 |
 |  __bytes__(self)
 |      Return the bytes representation of the path.  This is only
 |      recommended to use under Unix.
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __fspath__(self)
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __rtruediv__(self, key)
 |
 |  __str__(self)
 |      Return the string representation of the path, suitable for
 |      passing to system calls.
 |
 |  __truediv__(self, key)
 |
 |  as_posix(self)
 |      Return the string representation of the path with forward (/)
 |      slashes.
 |
 |  as_uri(self)
 |      Return the path as a 'file' URI.
 |
 |  is_absolute(self)
 |      True if the path is absolute (has both a root and, if applicable,
 |      a drive).
 |
 |  is_relative_to(self, other, /, *_deprecated)
 |      Return True if the path is relative to another path or False.
 |
 |  is_reserved(self)
 |      Return True if the path contains one of the special names reserved
 |      by the system, if any.
 |
 |  joinpath(self, *pathsegments)
 |      Combine this path with one or several arguments, and return a
 |      new path representing either a subpath (if all arguments are relative
 |      paths) or a totally different path (if one of the arguments is
 |      anchored).
 |
 |  match(self, path_pattern, *, case_sensitive=None)
 |      Return True if this path matches the given pattern.
 |
 |  relative_to(self, other, /, *_deprecated, walk_up=False)
 |      Return the relative path to another path identified by the passed
 |      arguments.  If the operation is not possible (because this is not
 |      related to the other path), raise ValueError.
 |
 |      The *walk_up* parameter controls whether `..` may be used to resolve
 |      the path.
 |
 |  with_name(self, name)
 |      Return a new path with the file name changed.
 |
 |  with_segments(self, *pathsegments)
 |      Construct a new path object from any number of path-like objects.
 |      Subclasses may override this method to customize how new path objects
 |      are created from methods like `iterdir()`.
 |
 |  with_stem(self, stem)
 |      Return a new path with the stem changed.
 |
 |  with_suffix(self, suffix)
 |      Return a new path with the file suffix changed.  If the path
 |      has no suffix, add given suffix.  If the given suffix is an empty
 |      string, remove the suffix from the path.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from PurePath:
 |
 |  anchor
 |      The concatenation of the drive and root, or ''.
 |
 |  drive
 |      The drive prefix (letter or UNC path), if any.
 |
 |  name
 |      The final path component, if any.
 |
 |  parent
 |      The logical parent of the path.
 |
 |  parents
 |      A sequence of this path's logical parents.
 |
 |  parts
 |      An object providing sequence-like access to the
 |      components in the filesystem path.
 |
 |  root
 |      The root of the path, if any.
 |
 |  stem
 |      The final path component, minus its last suffix.
 |
 |  suffix
 |      The final component's last suffix, if any.
 |
 |      This includes the leading period. For example: '.txt'
 |
 |  suffixes
 |      A list of the final component's suffixes, if any.
 |
 |      These include the leading periods. For example: ['.tar', '.gz']

Python Library Documentation: class FileUrl in module pydantic.networks

class FileUrl(AnyUrl)
 |  FileUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any file URL.
 |
 |  * Host not required
 |
 |  Method resolution order:
 |      FileUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: class FtpUrl in module pydantic.networks

class FtpUrl(AnyUrl)
 |  FtpUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept ftp URL.
 |
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      FtpUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class FutureDate in module pydantic.types

class FutureDate(builtins.object)
 |  A date in the future.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class FutureDatetime in module pydantic.types

class FutureDatetime(builtins.object)
 |  A datetime that must be in the future.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class GetCoreSchemaHandler in module pydantic.annotated_handlers

class GetCoreSchemaHandler(builtins.object)
 |  Handler to call into the next CoreSchema schema generation function.
 |
 |  Methods defined here:
 |
 |  __call__(self, source_type: 'Any', /) -> 'core_schema.CoreSchema'
 |      Call the inner handler and get the CoreSchema it returns.
 |      This will call the next CoreSchema modifying function up until it calls
 |      into Pydantic's internal schema generation machinery, which will raise a
 |      `pydantic.errors.PydanticSchemaGenerationError` error if it cannot generate
 |      a CoreSchema for the given source type.
 |
 |      Args:
 |          source_type: The input type.
 |
 |      Returns:
 |          CoreSchema: The `pydantic-core` CoreSchema generated.
 |
 |  generate_schema(self, source_type: 'Any', /) -> 'core_schema.CoreSchema'
 |      Generate a schema unrelated to the current context.
 |      Use this function if e.g. you are handling schema generation for a sequence
 |      and want to generate a schema for its items.
 |      Otherwise, you may end up doing something like applying a `min_length` constraint
 |      that was intended for the sequence itself to its items!
 |
 |      Args:
 |          source_type: The input type.
 |
 |      Returns:
 |          CoreSchema: The `pydantic-core` CoreSchema generated.
 |
 |  resolve_ref_schema(self, maybe_ref_schema: 'core_schema.CoreSchema', /) -> 'core_schema.CoreSchema'
 |      Get the real schema for a `definition-ref` schema.
 |      If the schema given is not a `definition-ref` schema, it will be returned as is.
 |      This means you don't have to check before calling this function.
 |
 |      Args:
 |          maybe_ref_schema: A `CoreSchema`, `ref`-based or not.
 |
 |      Raises:
 |          LookupError: If the `ref` is not found.
 |
 |      Returns:
 |          A concrete `CoreSchema`.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  field_name
 |      Get the name of the closest field to this validator.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class GetJsonSchemaHandler in module pydantic.annotated_handlers

class GetJsonSchemaHandler(builtins.object)
 |  Handler to call into the next JSON schema generation function.
 |
 |  Attributes:
 |      mode: Json schema mode, can be `validation` or `serialization`.
 |
 |  Methods defined here:
 |
 |  __call__(self, core_schema: 'CoreSchemaOrField', /) -> 'JsonSchemaValue'
 |      Call the inner handler and get the JsonSchemaValue it returns.
 |      This will call the next JSON schema modifying function up until it calls
 |      into `pydantic.json_schema.GenerateJsonSchema`, which will raise a
 |      `pydantic.errors.PydanticInvalidForJsonSchema` error if it cannot generate
 |      a JSON schema.
 |
 |      Args:
 |          core_schema: A `pydantic_core.core_schema.CoreSchema`.
 |
 |      Returns:
 |          JsonSchemaValue: The JSON schema generated by the inner JSON schema modify
 |          functions.
 |
 |  resolve_ref_schema(self, maybe_ref_json_schema: 'JsonSchemaValue', /) -> 'JsonSchemaValue'
 |      Get the real schema for a `{"$ref": ...}` schema.
 |      If the schema given is not a `$ref` schema, it will be returned as is.
 |      This means you don't have to check before calling this function.
 |
 |      Args:
 |          maybe_ref_json_schema: A JsonSchemaValue which may be a `$ref` schema.
 |
 |      Raises:
 |          LookupError: If the ref is not found.
 |
 |      Returns:
 |          JsonSchemaValue: A JsonSchemaValue that has no `$ref`.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'mode': 'JsonSchemaMode'}

Python Library Documentation: class GetPydanticSchema in module pydantic.types

class GetPydanticSchema(builtins.object)
 |  GetPydanticSchema(get_pydantic_core_schema: 'Callable[[Any, GetCoreSchemaHandler], CoreSchema] | None' = None, get_pydantic_json_schema: 'Callable[[Any, GetJsonSchemaHandler], JsonSchemaValue] | None' = None) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [Using `GetPydanticSchema` to Reduce Boilerplate](../concepts/types.md#using-getpydanticschema-to-reduce-boilerplate)
 |
 |  A convenience class for creating an annotation that provides pydantic custom type hooks.
 |
 |  This class is intended to eliminate the need to create a custom "marker" which defines the
 |   `__get_pydantic_core_schema__` and `__get_pydantic_json_schema__` custom hook methods.
 |
 |  For example, to have a field treated by type checkers as `int`, but by pydantic as `Any`, you can do:
 |  ```python
 |  from typing import Annotated, Any
 |
 |  from pydantic import BaseModel, GetPydanticSchema
 |
 |  HandleAsAny = GetPydanticSchema(lambda _s, h: h(Any))
 |
 |  class Model(BaseModel):
 |      x: Annotated[int, HandleAsAny]  # pydantic sees `x: Any`
 |
 |  print(repr(Model(x='abc').x))
 |  #> 'abc'
 |  ```
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __getattr__(self, item: 'str') -> 'Any'
 |      Use this rather than defining `__get_pydantic_core_schema__` etc. to reduce the number of nested calls.
 |
 |  __hash__(self, /) from builtins.object
 |      Return hash(self).
 |
 |  __init__(self, get_pydantic_core_schema: 'Callable[[Any, GetCoreSchemaHandler], CoreSchema] | None' = None, get_pydantic_json_schema: 'Callable[[Any, GetJsonSchemaHandler], JsonSchemaValue] | None' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  get_pydantic_core_schema
 |
 |  get_pydantic_json_schema
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'get_pydantic_core_schema': 'Callable[[Any, GetCore...
 |
 |  __dataclass_fields__ = {'get_pydantic_core_schema': Field(name='get_py...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('get_pydantic_core_schema', 'get_pydantic_json_schem...

Python Library Documentation: class HttpUrl in module pydantic.networks

class HttpUrl(AnyUrl)
 |  HttpUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any http or https URL.
 |
 |  * TLD not required
 |  * Host not required
 |  * Max length 2083
 |
 |  ```python
 |  from pydantic import BaseModel, HttpUrl, ValidationError
 |
 |  class MyModel(BaseModel):
 |      url: HttpUrl
 |
 |  m = MyModel(url='http://www.example.com')  # (1)!
 |  print(m.url)
 |  #> http://www.example.com/
 |
 |  try:
 |      MyModel(url='ftp://invalid.url')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for MyModel
 |      url
 |        URL scheme should be 'http' or 'https' [type=url_scheme, input_value='ftp://invalid.url', input_type=str]
 |      '''
 |
 |  try:
 |      MyModel(url='not a url')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for MyModel
 |      url
 |        Input should be a valid URL, relative URL without a base [type=url_parsing, input_value='not a url', input_type=str]
 |      '''
 |  ```
 |
 |  1. Note: mypy would prefer `m = MyModel(url=HttpUrl('http://www.example.com'))`, but Pydantic will convert the string to an HttpUrl instance anyway.
 |
 |  "International domains" (e.g. a URL where the host or TLD includes non-ascii characters) will be encoded via
 |  [punycode](https://en.wikipedia.org/wiki/Punycode) (see
 |  [this article](https://www.xudongz.com/blog/2017/idn-phishing/) for a good description of why this is important):
 |
 |  ```python
 |  from pydantic import BaseModel, HttpUrl
 |
 |  class MyModel(BaseModel):
 |      url: HttpUrl
 |
 |  m1 = MyModel(url='http://puny£code.com')
 |  print(m1.url)
 |  #> http://xn--punycode-eja.com/
 |  m2 = MyModel(url='https://www.аррӏе.com/')
 |  print(m2.url)
 |  #> https://www.xn--80ak6aa92e.com/
 |  m3 = MyModel(url='https://www.example.珠宝/')
 |  print(m3.url)
 |  #> https://www.example.xn--pbt977c/
 |  ```
 |
 |
 |  !!! warning "Underscores in Hostnames"
 |      In Pydantic, underscores are allowed in all parts of a domain except the TLD.
 |      Technically this might be wrong - in theory the hostname cannot have underscores, but subdomains can.
 |
 |      To explain this; consider the following two cases:
 |
 |      - `exam_ple.co.uk`: the hostname is `exam_ple`, which should not be allowed since it contains an underscore.
 |      - `foo_bar.example.com` the hostname is `example`, which should be allowed since the underscore is in the subdomain.
 |
 |      Without having an exhaustive list of TLDs, it would be impossible to differentiate between these two. Therefore
 |      underscores are allowed, but you can always do further validation in a validator if desired.
 |
 |      Also, Chrome, Firefox, and Safari all currently accept `http://exam_ple.com` as a URL, so we're in good
 |      (or at least big) company.
 |
 |  Method resolution order:
 |      HttpUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class IPvAnyAddress in module pydantic.networks

class IPvAnyAddress(builtins.object)
 |  IPvAnyAddress(value: 'Any') -> 'IPvAnyAddressType'
 |
 |  Validate an IPv4 or IPv6 address.
 |
 |  ```python
 |  from pydantic import BaseModel
 |  from pydantic.networks import IPvAnyAddress
 |
 |  class IpModel(BaseModel):
 |      ip: IPvAnyAddress
 |
 |  print(IpModel(ip='127.0.0.1'))
 |  #> ip=IPv4Address('127.0.0.1')
 |
 |  try:
 |      IpModel(ip='http://www.example.com')
 |  except ValueError as e:
 |      print(e.errors())
 |      '''
 |      [
 |          {
 |              'type': 'ip_any_address',
 |              'loc': ('ip',),
 |              'msg': 'value is not a valid IPv4 or IPv6 address',
 |              'input': 'http://www.example.com',
 |          }
 |      ]
 |      '''
 |  ```
 |
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(_source: 'type[Any]', _handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, value: 'Any') -> 'IPvAnyAddressType'
 |      Validate an IPv4 or IPv6 address.

Python Library Documentation: class IPvAnyInterface in module pydantic.networks

class IPvAnyInterface(builtins.object)
 |  IPvAnyInterface(value: 'NetworkType') -> 'IPvAnyInterfaceType'
 |
 |  Validate an IPv4 or IPv6 interface.
 |
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(_source: 'type[Any]', _handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, value: 'NetworkType') -> 'IPvAnyInterfaceType'
 |      Validate an IPv4 or IPv6 interface.

Python Library Documentation: class IPvAnyNetwork in module pydantic.networks

class IPvAnyNetwork(builtins.object)
 |  IPvAnyNetwork(value: 'NetworkType') -> 'IPvAnyNetworkType'
 |
 |  Validate an IPv4 or IPv6 network.
 |
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(_source: 'type[Any]', _handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, value: 'NetworkType') -> 'IPvAnyNetworkType'
 |      Validate an IPv4 or IPv6 network.

Python Library Documentation: class ImportString in module pydantic.types

class ImportString(builtins.object)
 |  A type that can be used to import a Python object from a string.
 |
 |  `ImportString` expects a string and loads the Python object importable at that dotted path.
 |  Attributes of modules may be separated from the module by `:` or `.`, e.g. if `'math:cos'` is provided,
 |  the resulting field value would be the function `cos`. If a `.` is used and both an attribute and submodule
 |  are present at the same path, the module will be preferred.
 |
 |  On model instantiation, pointers will be evaluated and imported. There is
 |  some nuance to this behavior, demonstrated in the examples below.
 |
 |  ```python
 |  import math
 |
 |  from pydantic import BaseModel, Field, ImportString, ValidationError
 |
 |  class ImportThings(BaseModel):
 |      obj: ImportString
 |
 |  # A string value will cause an automatic import
 |  my_cos = ImportThings(obj='math.cos')
 |
 |  # You can use the imported function as you would expect
 |  cos_of_0 = my_cos.obj(0)
 |  assert cos_of_0 == 1
 |
 |  # A string whose value cannot be imported will raise an error
 |  try:
 |      ImportThings(obj='foo.bar')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for ImportThings
 |      obj
 |        Invalid python path: No module named 'foo' [type=import_error, input_value='foo.bar', input_type=str]
 |      '''
 |
 |  # Actual python objects can be assigned as well
 |  my_cos = ImportThings(obj=math.cos)
 |  my_cos_2 = ImportThings(obj='math.cos')
 |  my_cos_3 = ImportThings(obj='math:cos')
 |  assert my_cos == my_cos_2 == my_cos_3
 |
 |  # You can set default field value either as Python object:
 |  class ImportThingsDefaultPyObj(BaseModel):
 |      obj: ImportString = math.cos
 |
 |  # or as a string value (but only if used with `validate_default=True`)
 |  class ImportThingsDefaultString(BaseModel):
 |      obj: ImportString = Field(default='math.cos', validate_default=True)
 |
 |  my_cos_default1 = ImportThingsDefaultPyObj()
 |  my_cos_default2 = ImportThingsDefaultString()
 |  assert my_cos_default1.obj == my_cos_default2.obj == math.cos
 |
 |  # note: this will not work!
 |  class ImportThingsMissingValidateDefault(BaseModel):
 |      obj: ImportString = 'math.cos'
 |
 |  my_cos_default3 = ImportThingsMissingValidateDefault()
 |  assert my_cos_default3.obj == 'math.cos'  # just string, not evaluated
 |  ```
 |
 |  Serializing an `ImportString` type to json is also possible.
 |
 |  ```python
 |  from pydantic import BaseModel, ImportString
 |
 |  class ImportThings(BaseModel):
 |      obj: ImportString
 |
 |  # Create an instance
 |  m = ImportThings(obj='math.cos')
 |  print(m)
 |  #> obj=<built-in function cos>
 |  print(m.model_dump_json())
 |  #> {"obj":"math.cos"}
 |  ```
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(item: 'AnyType') -> 'AnyType'
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(cs: 'CoreSchema', handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class InstanceOf in module pydantic.functional_validators

class InstanceOf(builtins.object)
 |  InstanceOf() -> None
 |
 |  Generic type for annotating a type that is an instance of a given class.
 |
 |  Example:
 |      ```python
 |      from pydantic import BaseModel, InstanceOf
 |
 |      class Foo:
 |          ...
 |
 |      class Bar(BaseModel):
 |          foo: InstanceOf[Foo]
 |
 |      Bar(foo=Foo())
 |      try:
 |          Bar(foo=42)
 |      except ValidationError as e:
 |          print(e)
 |          """
 |          [
 |          │   {
 |          │   │   'type': 'is_instance_of',
 |          │   │   'loc': ('foo',),
 |          │   │   'msg': 'Input should be an instance of Foo',
 |          │   │   'input': 42,
 |          │   │   'ctx': {'class': 'Foo'},
 |          │   │   'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of'
 |          │   }
 |          ]
 |          """
 |      ```
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self, /) from builtins.object
 |      Return hash(self).
 |
 |  __init__(self) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(item: 'AnyType') -> 'AnyType'
 |
 |  __get_pydantic_core_schema__(source: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __dataclass_fields__ = {}
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ()

Python Library Documentation: class Json in module pydantic.types

class Json(builtins.object)
 |  A special type wrapper which loads JSON before parsing.
 |
 |  You can use the `Json` data type to make Pydantic first load a raw JSON string before
 |  validating the loaded data into the parametrized type:
 |
 |  ```python
 |  from typing import Any
 |
 |  from pydantic import BaseModel, Json, ValidationError
 |
 |  class AnyJsonModel(BaseModel):
 |      json_obj: Json[Any]
 |
 |  class ConstrainedJsonModel(BaseModel):
 |      json_obj: Json[list[int]]
 |
 |  print(AnyJsonModel(json_obj='{"b": 1}'))
 |  #> json_obj={'b': 1}
 |  print(ConstrainedJsonModel(json_obj='[1, 2, 3]'))
 |  #> json_obj=[1, 2, 3]
 |
 |  try:
 |      ConstrainedJsonModel(json_obj=12)
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for ConstrainedJsonModel
 |      json_obj
 |        JSON input should be string, bytes or bytearray [type=json_type, input_value=12, input_type=int]
 |      '''
 |
 |  try:
 |      ConstrainedJsonModel(json_obj='[a, b]')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for ConstrainedJsonModel
 |      json_obj
 |        Invalid JSON: expected value at line 1 column 2 [type=json_invalid, input_value='[a, b]', input_type=str]
 |      '''
 |
 |  try:
 |      ConstrainedJsonModel(json_obj='["a", "b"]')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      2 validation errors for ConstrainedJsonModel
 |      json_obj.0
 |        Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
 |      json_obj.1
 |        Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='b', input_type=str]
 |      '''
 |  ```
 |
 |  When you dump the model using `model_dump` or `model_dump_json`, the dumped value will be the result of validation,
 |  not the original JSON string. However, you can use the argument `round_trip=True` to get the original JSON string back:
 |
 |  ```python
 |  from pydantic import BaseModel, Json
 |
 |  class ConstrainedJsonModel(BaseModel):
 |      json_obj: Json[list[int]]
 |
 |  print(ConstrainedJsonModel(json_obj='[1, 2, 3]').model_dump_json())
 |  #> {"json_obj":[1,2,3]}
 |  print(
 |      ConstrainedJsonModel(json_obj='[1, 2, 3]').model_dump_json(round_trip=True)
 |  )
 |  #> {"json_obj":"[1,2,3]"}
 |  ```
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(item: 'AnyType') -> 'AnyType'
 |
 |  __get_pydantic_core_schema__(source: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: TypeAliasType in module pydantic.types object

JsonValue = class TypeAliasType(builtins.object)
 |  JsonValue(name: str, value, *, type_params=())
 |
 |  Create named, parameterized type aliases.
 |
 |  This provides a backport of the new `type` statement in Python 3.12:
 |
 |      type ListOrSet[T] = list[T] | set[T]
 |
 |  is equivalent to:
 |
 |      T = TypeVar("T")
 |      ListOrSet = TypeAliasType("ListOrSet", list[T] | set[T], type_params=(T,))
 |
 |  The name ListOrSet can then be used as an alias for the type it refers to.
 |
 |  The type_params argument should contain all the type parameters used
 |  in the value of the type alias. If the alias is not generic, this
 |  argument is omitted.
 |
 |  Static type checkers should only support type aliases declared using
 |  TypeAliasType that follow these rules:
 |
 |  - The first argument (the name) must be a string literal.
 |  - The TypeAliasType instance must be immediately assigned to a variable
 |    of the same name. (For example, 'X = TypeAliasType("Y", int)' is invalid,
 |    as is 'X, Y = TypeAliasType("X", int), TypeAliasType("Y", int)').
 |
 |  Methods defined here:
 |
 |  __call__(self)
 |      Call self as a function.
 |
 |  __delattr__(self, name: str, /) -> Never
 |      Implement delattr(self, name).
 |
 |  __getitem__(self, parameters)
 |
 |  __init__(self, name: str, value, *, type_params=())
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __or__(self, right)
 |      Return self|value.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self) -> str
 |      Return repr(self).
 |
 |  __ror__(self, left)
 |      Return value|self.
 |
 |  __setattr__(self, name: str, value: object, /) -> None
 |      Implement setattr(self, name, value).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __init_subclass__(*args, **kwargs)
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class KafkaDsn in module pydantic.networks

class KafkaDsn(AnyUrl)
 |  KafkaDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any Kafka DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      KafkaDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class MariaDBDsn in module pydantic.networks

class MariaDBDsn(AnyUrl)
 |  MariaDBDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any MariaDB DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      MariaDBDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class ModelWrapValidatorHandler in module pydantic.functional_validators

class ModelWrapValidatorHandler(pydantic_core.core_schema.ValidatorFunctionWrapHandler, typing.Protocol)
 |  ModelWrapValidatorHandler(*args, **kwargs)
 |
 |  `@model_validator` decorated function handler argument type. This is used when `mode='wrap'`.
 |
 |  Method resolution order:
 |      ModelWrapValidatorHandler
 |      pydantic_core.core_schema.ValidatorFunctionWrapHandler
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, value: 'Any', outer_location: 'str | int | None' = None, /) -> '_ModelTypeCo'
 |      Call self as a function.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __orig_bases__ = (<class 'pydantic_core.core_schema.ValidatorFunctionW...
 |
 |  __parameters__ = (+_ModelTypeCo,)
 |
 |  __protocol_attrs__ = {'__call__'}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic_core.core_schema.ValidatorFunctionWrapHandler:
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pydantic_core.core_schema.ValidatorFunctionWrapHandler:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class MongoDsn in module pydantic.networks

class MongoDsn(_BaseMultiHostUrl)
 |  MongoDsn(url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |
 |  A type that will accept any MongoDB DSN.
 |
 |  * User info not required
 |  * Database name not required
 |  * Port not required
 |  * User info may be passed without user part (e.g., `mongodb://mongodb0.example.com:27017`).
 |
 |  !!! warning
 |      If a port isn't specified, the default MongoDB port `27017` will be used. If this behavior is
 |      undesirable, you can use the following:
 |
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic_core import MultiHostUrl
 |
 |      from pydantic import UrlConstraints
 |
 |      MongoDsnNoDefaultPort = Annotated[
 |          MultiHostUrl,
 |          UrlConstraints(allowed_schemes=['mongodb', 'mongodb+srv']),
 |      ]
 |      ```
 |
 |  Method resolution order:
 |      MongoDsn
 |      _BaseMultiHostUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseMultiHostUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __len__(self) -> 'int'
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  hosts(self) -> 'list[MultiHostHost]'
 |      The hosts of the `MultiHostUrl` as [`MultiHostHost`][pydantic_core.MultiHostHost] typed dicts.
 |
 |      ```python
 |      from pydantic_core import MultiHostUrl
 |
 |      mhu = MultiHostUrl('https://foo.com:123,foo:bar@bar.com/path')
 |      print(mhu.hosts())
 |      """
 |      [
 |          {'username': None, 'password': None, 'host': 'foo.com', 'port': 123},
 |          {'username': 'foo', 'password': 'bar', 'host': 'bar.com', 'port': 443}
 |      ]
 |      ```
 |      Returns:
 |          A list of dicts, each representing a host.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?foo=bar#fragment`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseMultiHostUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseMultiHostUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', hosts: 'list[MultiHostHost] | None' = None, username: 'str | None' = None, password: 'str | None' = None, host: 'str | None' = None, port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `MultiHostUrl` instance from its component parts.
 |
 |      This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
 |      `username`, `password`, `host` and `port`.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          hosts: Multiple hosts to build the URL from.
 |          username: The username part of the URL.
 |          password: The password part of the URL.
 |          host: The host part of the URL.
 |          port: The port part of the URL.
 |          path: The path part of the URL.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of `MultiHostUrl`
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseMultiHostUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseMultiHostUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseMultiHostUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class MySQLDsn in module pydantic.networks

class MySQLDsn(AnyUrl)
 |  MySQLDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any MySQL DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host not required
 |
 |  Method resolution order:
 |      MySQLDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class NaiveDatetime in module pydantic.types

class NaiveDatetime(builtins.object)
 |  A datetime that doesn't require timezone info.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class NameEmail in module pydantic.networks

class NameEmail(pydantic._internal._repr.Representation)
 |  NameEmail(name: 'str', email: 'str')
 |
 |  Info:
 |      To use this type, you need to install the optional
 |      [`email-validator`](https://github.com/JoshData/python-email-validator) package:
 |
 |      ```bash
 |      pip install email-validator
 |      ```
 |
 |  Validate a name and email address combination, as specified by
 |  [RFC 5322](https://datatracker.ietf.org/doc/html/rfc5322#section-3.4).
 |
 |  The `NameEmail` has two properties: `name` and `email`.
 |  In case the `name` is not provided, it's inferred from the email address.
 |
 |  ```python
 |  from pydantic import BaseModel, NameEmail
 |
 |  class User(BaseModel):
 |      email: NameEmail
 |
 |  user = User(email='Fred Bloggs <fred.bloggs@example.com>')
 |  print(user.email)
 |  #> Fred Bloggs <fred.bloggs@example.com>
 |  print(user.email.name)
 |  #> Fred Bloggs
 |
 |  user = User(email='fred.bloggs@example.com')
 |  print(user.email)
 |  #> fred.bloggs <fred.bloggs@example.com>
 |  print(user.email.name)
 |  #> fred.bloggs
 |  ```
 |
 |  Method resolution order:
 |      NameEmail
 |      pydantic._internal._repr.Representation
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __init__(self, name: 'str', email: 'str')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(_source: 'type[Any]', _handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  email
 |
 |  name
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  __hash__ = None
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic._internal._repr.Representation:
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __repr_args__(self) -> 'ReprArgs'
 |      Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
 |
 |      Can either return:
 |      * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
 |      * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
 |
 |  __repr_name__(self) -> 'str'
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str'
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str'
 |
 |  __rich_repr__(self) -> 'RichReprResult'
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.

Python Library Documentation: class NatsDsn in module pydantic.networks

class NatsDsn(_BaseMultiHostUrl)
 |  NatsDsn(url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |
 |  A type that will accept any NATS DSN.
 |
 |  NATS is a connective technology built for the ever increasingly hyper-connected world.
 |  It is a single technology that enables applications to securely communicate across
 |  any combination of cloud vendors, on-premise, edge, web and mobile, and devices.
 |  More: https://nats.io
 |
 |  Method resolution order:
 |      NatsDsn
 |      _BaseMultiHostUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseMultiHostUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __len__(self) -> 'int'
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  hosts(self) -> 'list[MultiHostHost]'
 |      The hosts of the `MultiHostUrl` as [`MultiHostHost`][pydantic_core.MultiHostHost] typed dicts.
 |
 |      ```python
 |      from pydantic_core import MultiHostUrl
 |
 |      mhu = MultiHostUrl('https://foo.com:123,foo:bar@bar.com/path')
 |      print(mhu.hosts())
 |      """
 |      [
 |          {'username': None, 'password': None, 'host': 'foo.com', 'port': 123},
 |          {'username': 'foo', 'password': 'bar', 'host': 'bar.com', 'port': 443}
 |      ]
 |      ```
 |      Returns:
 |          A list of dicts, each representing a host.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?foo=bar#fragment`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseMultiHostUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseMultiHostUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', hosts: 'list[MultiHostHost] | None' = None, username: 'str | None' = None, password: 'str | None' = None, host: 'str | None' = None, port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `MultiHostUrl` instance from its component parts.
 |
 |      This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
 |      `username`, `password`, `host` and `port`.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          hosts: Multiple hosts to build the URL from.
 |          username: The username part of the URL.
 |          password: The password part of the URL.
 |          host: The host part of the URL.
 |          port: The port part of the URL.
 |          path: The path part of the URL.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of `MultiHostUrl`
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseMultiHostUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseMultiHostUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseMultiHostUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class Path(PurePath)
 |  Annotated(*args, **kwargs)
 |
 |  PurePath subclass that can make system calls.
 |
 |  Path represents a filesystem path but unlike PurePath, also offers
 |  methods to do system calls on path objects. Depending on your system,
 |  instantiating a Path will return either a PosixPath or a WindowsPath
 |  object. You can also instantiate a PosixPath or WindowsPath directly,
 |  but cannot instantiate a WindowsPath on a POSIX system or vice versa.
 |
 |  Method resolution order:
 |      Path
 |      PurePath
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, t, v, tb)
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  absolute(self)
 |      Return an absolute version of this path by prepending the current
 |      working directory. No normalization or symlink resolution is performed.
 |
 |      Use resolve() to get the canonical path to a file.
 |
 |  chmod(self, mode, *, follow_symlinks=True)
 |      Change the permissions of the path, like os.chmod().
 |
 |  exists(self, *, follow_symlinks=True)
 |      Whether this path exists.
 |
 |      This method normally follows symlinks; to check whether a symlink exists,
 |      add the argument follow_symlinks=False.
 |
 |  expanduser(self)
 |      Return a new path with expanded ~ and ~user constructs
 |      (as returned by os.path.expanduser)
 |
 |  glob(self, pattern, *, case_sensitive=None)
 |      Iterate over this subtree and yield all existing files (of any
 |      kind, including directories) matching the given relative pattern.
 |
 |  group(self)
 |      Return the group name of the file gid.
 |
 |  hardlink_to(self, target)
 |      Make this path a hard link pointing to the same file as *target*.
 |
 |      Note the order of arguments (self, target) is the reverse of os.link's.
 |
 |  is_block_device(self)
 |      Whether this path is a block device.
 |
 |  is_char_device(self)
 |      Whether this path is a character device.
 |
 |  is_dir(self)
 |      Whether this path is a directory.
 |
 |  is_fifo(self)
 |      Whether this path is a FIFO.
 |
 |  is_file(self)
 |      Whether this path is a regular file (also True for symlinks pointing
 |      to regular files).
 |
 |  is_junction(self)
 |      Whether this path is a junction.
 |
 |  is_mount(self)
 |      Check if this path is a mount point
 |
 |  is_socket(self)
 |      Whether this path is a socket.
 |
 |  is_symlink(self)
 |      Whether this path is a symbolic link.
 |
 |  iterdir(self)
 |      Yield path objects of the directory contents.
 |
 |      The children are yielded in arbitrary order, and the
 |      special entries '.' and '..' are not included.
 |
 |  lchmod(self, mode)
 |      Like chmod(), except if the path points to a symlink, the symlink's
 |      permissions are changed, rather than its target's.
 |
 |  lstat(self)
 |      Like stat(), except if the path points to a symlink, the symlink's
 |      status information is returned, rather than its target's.
 |
 |  mkdir(self, mode=511, parents=False, exist_ok=False)
 |      Create a new directory at this given path.
 |
 |  open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
 |      Open the file pointed to by this path and return a file object, as
 |      the built-in open() function does.
 |
 |  owner(self)
 |      Return the login name of the file owner.
 |
 |  read_bytes(self)
 |      Open the file in bytes mode, read it, and close the file.
 |
 |  read_text(self, encoding=None, errors=None)
 |      Open the file in text mode, read it, and close the file.
 |
 |  readlink(self)
 |      Return the path to which the symbolic link points.
 |
 |  rename(self, target)
 |      Rename this path to the target path.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  replace(self, target)
 |      Rename this path to the target path, overwriting if that path exists.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  resolve(self, strict=False)
 |      Make the path absolute, resolving all symlinks on the way and also
 |      normalizing it.
 |
 |  rglob(self, pattern, *, case_sensitive=None)
 |      Recursively yield all existing files (of any kind, including
 |      directories) matching the given relative pattern, anywhere in
 |      this subtree.
 |
 |  rmdir(self)
 |      Remove this directory.  The directory must be empty.
 |
 |  samefile(self, other_path)
 |      Return whether other_path is the same or not as this file
 |      (as returned by os.path.samefile()).
 |
 |  stat(self, *, follow_symlinks=True)
 |      Return the result of the stat() system call on this path, like
 |      os.stat() does.
 |
 |  symlink_to(self, target, target_is_directory=False)
 |      Make this path a symlink pointing to the target path.
 |      Note the order of arguments (link, target) is the reverse of os.symlink.
 |
 |  touch(self, mode=438, exist_ok=True)
 |      Create this file with the given access mode, if it doesn't exist.
 |
 |  unlink(self, missing_ok=False)
 |      Remove this file or link.
 |      If the path is a directory, use rmdir() instead.
 |
 |  walk(self, top_down=True, on_error=None, follow_symlinks=False)
 |      Walk the directory tree from this directory, similar to os.walk().
 |
 |  write_bytes(self, data)
 |      Open the file in bytes mode, write to it, and close the file.
 |
 |  write_text(self, data, encoding=None, errors=None, newline=None)
 |      Open the file in text mode, write to it, and close the file.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  cwd()
 |      Return a new path pointing to the current working directory.
 |
 |  home()
 |      Return a new path pointing to the user's home directory (as
 |      returned by os.path.expanduser('~')).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, *args, **kwargs)
 |      Construct a PurePath from one or several strings and or existing
 |      PurePath objects.  The strings and path objects are combined so as
 |      to yield a canonicalized path, which is incorporated into the
 |      new PurePath object.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PurePath:
 |
 |  __bytes__(self)
 |      Return the bytes representation of the path.  This is only
 |      recommended to use under Unix.
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __fspath__(self)
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __rtruediv__(self, key)
 |
 |  __str__(self)
 |      Return the string representation of the path, suitable for
 |      passing to system calls.
 |
 |  __truediv__(self, key)
 |
 |  as_posix(self)
 |      Return the string representation of the path with forward (/)
 |      slashes.
 |
 |  as_uri(self)
 |      Return the path as a 'file' URI.
 |
 |  is_absolute(self)
 |      True if the path is absolute (has both a root and, if applicable,
 |      a drive).
 |
 |  is_relative_to(self, other, /, *_deprecated)
 |      Return True if the path is relative to another path or False.
 |
 |  is_reserved(self)
 |      Return True if the path contains one of the special names reserved
 |      by the system, if any.
 |
 |  joinpath(self, *pathsegments)
 |      Combine this path with one or several arguments, and return a
 |      new path representing either a subpath (if all arguments are relative
 |      paths) or a totally different path (if one of the arguments is
 |      anchored).
 |
 |  match(self, path_pattern, *, case_sensitive=None)
 |      Return True if this path matches the given pattern.
 |
 |  relative_to(self, other, /, *_deprecated, walk_up=False)
 |      Return the relative path to another path identified by the passed
 |      arguments.  If the operation is not possible (because this is not
 |      related to the other path), raise ValueError.
 |
 |      The *walk_up* parameter controls whether `..` may be used to resolve
 |      the path.
 |
 |  with_name(self, name)
 |      Return a new path with the file name changed.
 |
 |  with_segments(self, *pathsegments)
 |      Construct a new path object from any number of path-like objects.
 |      Subclasses may override this method to customize how new path objects
 |      are created from methods like `iterdir()`.
 |
 |  with_stem(self, stem)
 |      Return a new path with the stem changed.
 |
 |  with_suffix(self, suffix)
 |      Return a new path with the file suffix changed.  If the path
 |      has no suffix, add given suffix.  If the given suffix is an empty
 |      string, remove the suffix from the path.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from PurePath:
 |
 |  anchor
 |      The concatenation of the drive and root, or ''.
 |
 |  drive
 |      The drive prefix (letter or UNC path), if any.
 |
 |  name
 |      The final path component, if any.
 |
 |  parent
 |      The logical parent of the path.
 |
 |  parents
 |      A sequence of this path's logical parents.
 |
 |  parts
 |      An object providing sequence-like access to the
 |      components in the filesystem path.
 |
 |  root
 |      The root of the path, if any.
 |
 |  stem
 |      The final path component, minus its last suffix.
 |
 |  suffix
 |      The final component's last suffix, if any.
 |
 |      This includes the leading period. For example: '.txt'
 |
 |  suffixes
 |      A list of the final component's suffixes, if any.
 |
 |      These include the leading periods. For example: ['.tar', '.gz']

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = ~T

Python Library Documentation: class PastDate in module pydantic.types

class PastDate(builtins.object)
 |  A date in the past.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class PastDatetime in module pydantic.types

class PastDatetime(builtins.object)
 |  A datetime that must be in the past.
 |
 |  Methods defined here:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class PaymentCardNumber in module pydantic.types

class PaymentCardNumber(builtins.str)
 |  PaymentCardNumber(*args, **kwargs)
 |
 |  Based on: https://en.wikipedia.org/wiki/Payment_card_number.
 |
 |  Method resolution order:
 |      PaymentCardNumber
 |      builtins.str
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, card_number: 'str')
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __init_subclass__(*args, **kwargs) from typing_extensions.deprecated.__call__.<locals>
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  validate(input_value: 'str', /, _: 'core_schema.ValidationInfo') -> 'PaymentCardNumber'
 |      Validate the card number and return a `PaymentCardNumber` instance.
 |
 |  validate_digits(card_number: 'str') -> 'None'
 |      Validate that the card number is all digits.
 |
 |  validate_luhn_check_digit(card_number: 'str') -> 'str'
 |      Based on: https://en.wikipedia.org/wiki/Luhn_algorithm.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from str
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  validate_brand(card_number: 'str') -> 'PaymentCardBrand'
 |      Validate length based on BIN for major brands:
 |      https://en.wikipedia.org/wiki/Payment_card_number#Issuer_identification_number_(IIN).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  masked
 |      Mask all but the last 4 digits of the card number.
 |
 |      Returns:
 |          A masked card number string.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'bin': 'str', 'brand': 'PaymentCardBrand', 'last4':...
 |
 |  __deprecated__ = 'The `PaymentCardNumber` class is deprecated, use.../...
 |
 |  max_length = 19
 |
 |  min_length = 12
 |
 |  strip_whitespace = True
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.str:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the end of the string and works to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the front of the string and works to the end.
 |
 |      Note, str.split() is mainly useful for data that has been intentionally
 |      delimited.  With natural text that includes punctuation, consider using
 |      the regular expression module.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.str:
 |
 |  maketrans(...)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

Python Library Documentation: class PlainSerializer in module pydantic.functional_serializers

class PlainSerializer(builtins.object)
 |  PlainSerializer(func: 'core_schema.SerializerFunction', return_type: 'Any' = PydanticUndefined, when_used: 'WhenUsed' = 'always') -> None
 |
 |  Plain serializers use a function to modify the output of serialization.
 |
 |  This is particularly helpful when you want to customize the serialization for annotated types.
 |  Consider an input of `list`, which will be serialized into a space-delimited string.
 |
 |  ```python
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, PlainSerializer
 |
 |  CustomStr = Annotated[
 |      list, PlainSerializer(lambda x: ' '.join(x), return_type=str)
 |  ]
 |
 |  class StudentModel(BaseModel):
 |      courses: CustomStr
 |
 |  student = StudentModel(courses=['Math', 'Chemistry', 'English'])
 |  print(student.model_dump())
 |  #> {'courses': 'Math Chemistry English'}
 |  ```
 |
 |  Attributes:
 |      func: The serializer function.
 |      return_type: The return type for the function. If omitted it will be inferred from the type annotation.
 |      when_used: Determines when this serializer should be used. Accepts a string with values `'always'`,
 |          `'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'.
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |      Gets the Pydantic core schema.
 |
 |      Args:
 |          source_type: The source type.
 |          handler: The `GetCoreSchemaHandler` instance.
 |
 |      Returns:
 |          The Pydantic core schema.
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.SerializerFunction', return_type: 'Any' = PydanticUndefined, when_used: 'WhenUsed' = 'always') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  return_type
 |
 |  when_used
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.SerializerFunction', 'return_t...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.Se...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func', 'return_type', 'when_used')

Python Library Documentation: class PlainValidator in module pydantic.functional_validators

class PlainValidator(builtins.object)
 |  PlainValidator(func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction', json_schema_input_type: 'Any' = typing.Any) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [field *plain* validators](../concepts/validators.md#field-plain-validator)
 |
 |  A metadata class that indicates that a validation should be applied **instead** of the inner validation logic.
 |
 |  !!! note
 |      Before v2.9, `PlainValidator` wasn't always compatible with JSON Schema generation for `mode='validation'`.
 |      You can now use the `json_schema_input_type` argument to specify the input type of the function
 |      to be used in the JSON schema when `mode='validation'` (the default). See the example below for more details.
 |
 |  Attributes:
 |      func: The validator function.
 |      json_schema_input_type: The input type used to generate the appropriate
 |          JSON Schema (in validation mode). The actual input type is `Any`.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated, Union
 |
 |      from pydantic import BaseModel, PlainValidator
 |
 |      def validate(v: object) -> int:
 |          if not isinstance(v, (int, str)):
 |              raise ValueError(f'Expected int or str, got {type(v)}')
 |
 |          return int(v) + 1
 |
 |      MyInt = Annotated[
 |          int,
 |          PlainValidator(validate, json_schema_input_type=Union[str, int]),  # (1)!
 |      ]
 |
 |      class Model(BaseModel):
 |          a: MyInt
 |
 |      print(Model(a='1').a)
 |      #> 2
 |
 |      print(Model(a=1).a)
 |      #> 2
 |      ```
 |
 |      1. In this example, we've specified the `json_schema_input_type` as `Union[str, int]` which indicates to the JSON schema
 |      generator that in validation mode, the input type for the `a` field can be either a [`str`][] or an [`int`][].
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunction', json_schema_input_type: 'Any' = typing.Any) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  json_schema_input_type
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.NoInfoValidatorFunction | core...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.No...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func', 'json_schema_input_type')

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: class PostgresDsn in module pydantic.networks

class PostgresDsn(_BaseMultiHostUrl)
 |  PostgresDsn(url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |
 |  A type that will accept any Postgres DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host required
 |  * Supports multiple hosts
 |
 |  If further validation is required, these properties can be used by validators to enforce specific behaviour:
 |
 |  ```python
 |  from pydantic import (
 |      BaseModel,
 |      HttpUrl,
 |      PostgresDsn,
 |      ValidationError,
 |      field_validator,
 |  )
 |
 |  class MyModel(BaseModel):
 |      url: HttpUrl
 |
 |  m = MyModel(url='http://www.example.com')
 |
 |  # the repr() method for a url will display all properties of the url
 |  print(repr(m.url))
 |  #> HttpUrl('http://www.example.com/')
 |  print(m.url.scheme)
 |  #> http
 |  print(m.url.host)
 |  #> www.example.com
 |  print(m.url.port)
 |  #> 80
 |
 |  class MyDatabaseModel(BaseModel):
 |      db: PostgresDsn
 |
 |      @field_validator('db')
 |      def check_db_name(cls, v):
 |          assert v.path and len(v.path) > 1, 'database must be provided'
 |          return v
 |
 |  m = MyDatabaseModel(db='postgres://user:pass@localhost:5432/foobar')
 |  print(m.db)
 |  #> postgres://user:pass@localhost:5432/foobar
 |
 |  try:
 |      MyDatabaseModel(db='postgres://user:pass@localhost:5432')
 |  except ValidationError as e:
 |      print(e)
 |      '''
 |      1 validation error for MyDatabaseModel
 |      db
 |        Assertion failed, database must be provided
 |      assert (None)
 |       +  where None = PostgresDsn('postgres://user:pass@localhost:5432').path [type=assertion_error, input_value='postgres://user:pass@localhost:5432', input_type=str]
 |      '''
 |  ```
 |
 |  Method resolution order:
 |      PostgresDsn
 |      _BaseMultiHostUrl
 |      builtins.object
 |
 |  Readonly properties defined here:
 |
 |  host
 |      The required URL host.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseMultiHostUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreMultiHostUrl | _BaseMultiHostUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __len__(self) -> 'int'
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  hosts(self) -> 'list[MultiHostHost]'
 |      The hosts of the `MultiHostUrl` as [`MultiHostHost`][pydantic_core.MultiHostHost] typed dicts.
 |
 |      ```python
 |      from pydantic_core import MultiHostUrl
 |
 |      mhu = MultiHostUrl('https://foo.com:123,foo:bar@bar.com/path')
 |      print(mhu.hosts())
 |      """
 |      [
 |          {'username': None, 'password': None, 'host': 'foo.com', 'port': 123},
 |          {'username': 'foo', 'password': 'bar', 'host': 'bar.com', 'port': 443}
 |      ]
 |      ```
 |      Returns:
 |          A list of dicts, each representing a host.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?foo=bar#fragment`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseMultiHostUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseMultiHostUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', hosts: 'list[MultiHostHost] | None' = None, username: 'str | None' = None, password: 'str | None' = None, host: 'str | None' = None, port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `MultiHostUrl` instance from its component parts.
 |
 |      This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
 |      `username`, `password`, `host` and `port`.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          hosts: Multiple hosts to build the URL from.
 |          username: The username part of the URL.
 |          password: The password part of the URL.
 |          host: The host part of the URL.
 |          port: The port part of the URL.
 |          path: The path part of the URL.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of `MultiHostUrl`
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseMultiHostUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://foo.com,bar.com/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseMultiHostUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseMultiHostUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: function PrivateAttr in module pydantic.fields

PrivateAttr(default: 'Any' = PydanticUndefined, *, default_factory: 'Callable[[], Any] | Callable[[dict[str, Any]], Any] | None' = None, init: 'Literal[False]' = False) -> 'Any'
    !!! abstract "Usage Documentation"
        [Private Model Attributes](../concepts/models.md#private-model-attributes)

    Indicates that an attribute is intended for private use and not handled during normal validation/serialization.

    Private attributes are not validated by Pydantic, so it's up to you to ensure they are used in a type-safe manner.

    Private attributes are stored in `__private_attributes__` on the model.

    Args:
        default: The attribute's default value. Defaults to Undefined.
        default_factory: A callable to generate the default value. The callable can either take 0 arguments
            (in which case it is called as is) or a single argument containing the validated data (the model's
            [`__dict__`][object.__dict__]) and the already initialized private attributes.
            If both `default` and `default_factory` are set, an error will be raised.
        init: Whether the attribute should be included in the constructor of the dataclass. Always `False`.

    Returns:
        An instance of [`ModelPrivateAttr`][pydantic.fields.ModelPrivateAttr] class.

    Raises:
        ValueError: If both `default` and `default_factory` are set.

Python Library Documentation: class PydanticDeprecatedSince20 in module pydantic.warnings

class PydanticDeprecatedSince20(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince20(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.0.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince20
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecatedSince210 in module pydantic.warnings

class PydanticDeprecatedSince210(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince210(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.10.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince210
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecatedSince211 in module pydantic.warnings

class PydanticDeprecatedSince211(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince211(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.11.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince211
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecatedSince212 in module pydantic.warnings

class PydanticDeprecatedSince212(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince212(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.12.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince212
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecatedSince26 in module pydantic.warnings

class PydanticDeprecatedSince26(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince26(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.6.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince26
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecatedSince29 in module pydantic.warnings

class PydanticDeprecatedSince29(PydanticDeprecationWarning)
 |  PydanticDeprecatedSince29(message: 'str', *args: 'object') -> 'None'
 |
 |  A specific `PydanticDeprecationWarning` subclass defining functionality deprecated since Pydantic 2.9.
 |
 |  Method resolution order:
 |      PydanticDeprecatedSince29
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticDeprecationWarning:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticDeprecationWarning:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticDeprecationWarning in module pydantic.warnings

class PydanticDeprecationWarning(builtins.DeprecationWarning)
 |  PydanticDeprecationWarning(message: 'str', *args: 'object', since: 'tuple[int, int]', expected_removal: 'tuple[int, int] | None' = None) -> 'None'
 |
 |  A Pydantic specific deprecation warning.
 |
 |  This warning is raised when using deprecated functionality in Pydantic. It provides information on when the
 |  deprecation was introduced and the expected version in which the corresponding functionality will be removed.
 |
 |  Attributes:
 |      message: Description of the warning.
 |      since: Pydantic version in what the deprecation was introduced.
 |      expected_removal: Pydantic version in what the corresponding functionality expected to be removed.
 |
 |  Method resolution order:
 |      PydanticDeprecationWarning
 |      builtins.DeprecationWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str', *args: 'object', since: 'tuple[int, int]', expected_removal: 'tuple[int, int] | None' = None) -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'expected_removal': 'tuple[int, int]', 'message': '...
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.DeprecationWarning:
 |
 |  __new__(*args, **kwargs) class method of builtins.DeprecationWarning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: _LiteralGenericAlias in module typing

Literal = typing.Literal
    Special typing form to define literal types (a.k.a. value types).

    This form can be used to indicate to type checkers that the corresponding
    variable or function parameter has a value equivalent to the provided
    literal (or one of several literals)::

        def validate_simple(data: Any) -> Literal[True]:  # always returns True
            ...

        MODE = Literal['r', 'rb', 'w', 'wb']
        def open_helper(file: str, mode: MODE) -> str:
            ...

        open_helper('/some/path', 'r')  # Passes type check
        open_helper('/other/path', 'typo')  # Error in type checker

    Literal[...] cannot be subclassed. At runtime, an arbitrary value
    is allowed as type argument to Literal[...], but type checkers may
    impose restrictions.

Python Library Documentation: class PydanticExperimentalWarning in module pydantic.warnings

class PydanticExperimentalWarning(builtins.Warning)
 |  A Pydantic specific experimental functionality warning.
 |
 |  It is raised to warn users that the functionality may change or be removed in future versions of Pydantic.
 |
 |  Method resolution order:
 |      PydanticExperimentalWarning
 |      builtins.Warning
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Warning:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Warning:
 |
 |  __new__(*args, **kwargs) class method of builtins.Warning
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticForbiddenQualifier in module pydantic.errors

class PydanticForbiddenQualifier(PydanticUserError)
 |  PydanticForbiddenQualifier(qualifier: 'Qualifier', annotation: 'Any') -> 'None'
 |
 |  An error raised if a forbidden type qualifier is found in a type annotation.
 |
 |  Method resolution order:
 |      PydanticForbiddenQualifier
 |      PydanticUserError
 |      PydanticErrorMixin
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, qualifier: 'Qualifier', annotation: 'Any') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_qualifier_repr_map': 'ClassVar[dict[Qualifier, st...
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticUserError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.RuntimeError:
 |
 |  __new__(*args, **kwargs) class method of builtins.RuntimeError
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticImportError in module pydantic.errors

class PydanticImportError(PydanticErrorMixin, builtins.ImportError)
 |  PydanticImportError(message: 'str') -> 'None'
 |
 |  An error raised when an import fails due to module changes between V1 and V2.
 |
 |  Attributes:
 |      message: Description of the error.
 |
 |  Method resolution order:
 |      PydanticImportError
 |      PydanticErrorMixin
 |      builtins.ImportError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.ImportError:
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.ImportError:
 |
 |  msg
 |      exception message
 |
 |  name
 |      module name
 |
 |  name_from
 |      name imported from module
 |
 |  path
 |      module path
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticInvalidForJsonSchema in module pydantic.errors

class PydanticInvalidForJsonSchema(PydanticUserError)
 |  PydanticInvalidForJsonSchema(message: 'str') -> 'None'
 |
 |  An error raised during failures to generate a JSON schema for some `CoreSchema`.
 |
 |  Attributes:
 |      message: Description of the error.
 |
 |  Method resolution order:
 |      PydanticInvalidForJsonSchema
 |      PydanticUserError
 |      PydanticErrorMixin
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticUserError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.RuntimeError:
 |
 |  __new__(*args, **kwargs) class method of builtins.RuntimeError
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticSchemaGenerationError in module pydantic.errors

class PydanticSchemaGenerationError(PydanticUserError)
 |  PydanticSchemaGenerationError(message: 'str') -> 'None'
 |
 |  An error raised during failures to generate a `CoreSchema` for some type.
 |
 |  Attributes:
 |      message: Description of the error.
 |
 |  Method resolution order:
 |      PydanticSchemaGenerationError
 |      PydanticUserError
 |      PydanticErrorMixin
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, message: 'str') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticUserError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.RuntimeError:
 |
 |  __new__(*args, **kwargs) class method of builtins.RuntimeError
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticUndefinedAnnotation in module pydantic.errors

class PydanticUndefinedAnnotation(PydanticErrorMixin, builtins.NameError)
 |  PydanticUndefinedAnnotation(name: 'str', message: 'str') -> 'None'
 |
 |  A subclass of `NameError` raised when handling undefined annotations during `CoreSchema` generation.
 |
 |  Attributes:
 |      name: Name of the error.
 |      message: Description of the error.
 |
 |  Method resolution order:
 |      PydanticUndefinedAnnotation
 |      PydanticErrorMixin
 |      builtins.NameError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, name: 'str', message: 'str') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_name_error(name_error: 'NameError') -> 'Self'
 |      Convert a `NameError` to a `PydanticUndefinedAnnotation` error.
 |
 |      Args:
 |          name_error: `NameError` to be converted.
 |
 |      Returns:
 |          Converted `PydanticUndefinedAnnotation` error.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.NameError:
 |
 |  name
 |      name
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PydanticUserError in module pydantic.errors

class PydanticUserError(PydanticErrorMixin, builtins.RuntimeError)
 |  PydanticUserError(message: 'str', *, code: 'PydanticErrorCodes | None') -> 'None'
 |
 |  An error raised due to incorrect use of Pydantic.
 |
 |  Method resolution order:
 |      PydanticUserError
 |      PydanticErrorMixin
 |      builtins.RuntimeError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PydanticErrorMixin:
 |
 |  __init__(self, message: 'str', *, code: 'PydanticErrorCodes | None') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from PydanticErrorMixin:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.RuntimeError:
 |
 |  __new__(*args, **kwargs) class method of builtins.RuntimeError
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class RedisDsn in module pydantic.networks

class RedisDsn(AnyUrl)
 |  RedisDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any Redis DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host required (e.g., `rediss://:pass@localhost`)
 |
 |  Method resolution order:
 |      RedisDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Readonly properties defined here:
 |
 |  host
 |      The required URL host.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class RootModel in module pydantic.root_model

class RootModel(pydantic.main.BaseModel, typing.Generic)
 |  RootModel(root: 'RootModelRootType' = PydanticUndefined) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [`RootModel` and Custom Root Types](../concepts/models.md#rootmodel-and-custom-root-types)
 |
 |  A Pydantic `BaseModel` for the root object of the model.
 |
 |  Attributes:
 |      root: The root object of the model.
 |      __pydantic_root_model__: Whether the model is a RootModel.
 |      __pydantic_private__: Private fields in the model.
 |      __pydantic_extra__: Extra fields in the model.
 |
 |  Method resolution order:
 |      RootModel
 |      pydantic.main.BaseModel
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __copy__(self) -> 'Self'
 |      Returns a shallow copy of the model.
 |
 |  __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
 |      Returns a deep copy of the model.
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __getstate__(self) -> 'dict[Any, Any]'
 |      Helper for pickle.
 |
 |  __init__(self, /, root: 'RootModelRootType' = PydanticUndefined, **data) -> 'None'
 |      Create a new model by parsing and validating input data from keyword arguments.
 |
 |      Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
 |      validated to form a valid model.
 |
 |      `self` is explicitly positional-only to allow `self` as a field name.
 |
 |  __repr_args__(self) -> '_repr.ReprArgs'
 |
 |  __setstate__(self, state: 'dict[Any, Any]') -> 'None'
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __init_subclass__(**kwargs)
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  model_construct(root: 'RootModelRootType', _fields_set: 'set[str] | None' = None) -> 'Self'
 |      Create a new model using the provided root object and update fields set.
 |
 |      Args:
 |          root: The root object of the model.
 |          _fields_set: The set of fields to be updated.
 |
 |      Returns:
 |          The new model.
 |
 |      Raises:
 |          NotImplemented: If the model is not a subclass of `RootModel`.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {'root': 'RootModelRootType'}
 |
 |  __class_vars__ = set()
 |
 |  __hash__ = None
 |
 |  __orig_bases__ = (<class 'pydantic.main.BaseModel'>, typing.Generic[~R...
 |
 |  __parameters__ = (~RootModelRootType,)
 |
 |  __private_attributes__ = {}
 |
 |  __pydantic_complete__ = True
 |
 |  __pydantic_computed_fields__ = {}
 |
 |  __pydantic_core_schema__ = {'cls': <class 'pydantic.root_model.RootMod...
 |
 |  __pydantic_custom_init__ = False
 |
 |  __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
 |
 |  __pydantic_extra__ = None
 |
 |  __pydantic_extra_info__ = None
 |
 |  __pydantic_fields__ = {'root': FieldInfo(annotation=TypeVar, required=...
 |
 |  __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
 |
 |  __pydantic_parent_namespace__ = None
 |
 |  __pydantic_post_init__ = None
 |
 |  __pydantic_private__ = None
 |
 |  __pydantic_root_model__ = True
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
 |
 |  __pydantic_setattr_handlers__ = {}
 |
 |  __pydantic_validator__ = SchemaValidator(title="RootModel", validator=...
 |
 |  __signature__ = <Signature (root: 'RootModelRootType' = PydanticUndefi...
 |
 |  model_config = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic.main.BaseModel:
 |
 |  __delattr__(self, item: 'str') -> 'Any'
 |      Implement delattr(self, name).
 |
 |  __getattr__(self, item: 'str') -> 'Any'
 |
 |  __iter__(self) -> 'TupleGenerator'
 |      So `dict(model)` works.
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __replace__(self, **changes: 'Any') -> 'Self'
 |      # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
 |      # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
 |
 |  __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
 |
 |  __setattr__(self, name: 'str', value: 'Any') -> 'None'
 |      Implement setattr(self, name, value).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
 |      Returns a copy of the model.
 |
 |      !!! warning "Deprecated"
 |          This method is now deprecated; use `model_copy` instead.
 |
 |      If you need `include` or `exclude`, use:
 |
 |      ```python {test="skip" lint="skip"}
 |      data = self.model_dump(include=include, exclude=exclude, round_trip=True)
 |      data = {**data, **(update or {})}
 |      copied = self.model_validate(data)
 |      ```
 |
 |      Args:
 |          include: Optional set or mapping specifying which fields to include in the copied model.
 |          exclude: Optional set or mapping specifying which fields to exclude in the copied model.
 |          update: Optional dictionary of field-value pairs to override field values in the copied model.
 |          deep: If True, the values of fields that are Pydantic models will be deep-copied.
 |
 |      Returns:
 |          A copy of the model with included, excluded and updated fields as specified.
 |
 |  dict(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False) -> 'Dict[str, Any]'
 |
 |  json(self, *, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool' = False, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
 |
 |  model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
 |      !!! abstract "Usage Documentation"
 |          [`model_copy`](../concepts/models.md#model-copy)
 |
 |      Returns a copy of the model.
 |
 |      !!! note
 |          The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
 |          might have unexpected side effects if you store anything in it, on top of the model
 |          fields (e.g. the value of [cached properties][functools.cached_property]).
 |
 |      Args:
 |          update: Values to change/add in the new model. Note: the data is not validated
 |              before creating the new model. You should trust this data.
 |          deep: Set to `True` to make a deep copy of the model.
 |
 |      Returns:
 |          New model instance.
 |
 |  model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
 |      !!! abstract "Usage Documentation"
 |          [`model_dump`](../concepts/serialization.md#python-mode)
 |
 |      Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
 |
 |      Args:
 |          mode: The mode in which `to_python` should run.
 |              If mode is 'json', the output will only contain JSON serializable types.
 |              If mode is 'python', the output may contain non-JSON-serializable Python objects.
 |          include: A set of fields to include in the output.
 |          exclude: A set of fields to exclude from the output.
 |          context: Additional context to pass to the serializer.
 |          by_alias: Whether to use the field's alias in the dictionary key if defined.
 |          exclude_unset: Whether to exclude fields that have not been explicitly set.
 |          exclude_defaults: Whether to exclude fields that are set to their default value.
 |          exclude_none: Whether to exclude fields that have a value of `None`.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |
 |      Returns:
 |          A dictionary representation of the model.
 |
 |  model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
 |      !!! abstract "Usage Documentation"
 |          [`model_dump_json`](../concepts/serialization.md#json-mode)
 |
 |      Generates a JSON representation of the model using Pydantic's `to_json` method.
 |
 |      Args:
 |          indent: Indentation to use in the JSON output. If None is passed, the output will be compact.
 |          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
 |              If `False` (the default), these characters will be output as-is.
 |          include: Field(s) to include in the JSON output.
 |          exclude: Field(s) to exclude from the JSON output.
 |          context: Additional context to pass to the serializer.
 |          by_alias: Whether to serialize using field aliases.
 |          exclude_unset: Whether to exclude fields that have not been explicitly set.
 |          exclude_defaults: Whether to exclude fields that are set to their default value.
 |          exclude_none: Whether to exclude fields that have a value of `None`.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |
 |      Returns:
 |          A JSON string representation of the model.
 |
 |  model_post_init(self, context: 'Any', /) -> 'None'
 |      Override this method to perform additional initialization after `__init__` and `model_construct`.
 |      This is useful if you want to do some validation that requires the entire model to be initialized.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from pydantic.main.BaseModel:
 |
 |  __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
 |      Hook into generating the model's JSON schema.
 |
 |      Args:
 |          core_schema: A `pydantic-core` CoreSchema.
 |              You can ignore this argument and call the handler with a new CoreSchema,
 |              wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
 |              or just call the handler with the original schema.
 |          handler: Call into Pydantic's internal JSON schema generation.
 |              This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
 |              generation fails.
 |              Since this gets called by `BaseModel.model_json_schema` you can override the
 |              `schema_generator` argument to that function to change JSON schema generation globally
 |              for a type.
 |
 |      Returns:
 |          A JSON schema, as a Python object.
 |
 |  __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
 |      This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
 |      only after basic class initialization is complete. In particular, attributes like `model_fields` will
 |      be present when this is called, but forward annotations are not guaranteed to be resolved yet,
 |      meaning that creating an instance of the class may fail.
 |
 |      This is necessary because `__init_subclass__` will always be called by `type.__new__`,
 |      and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
 |      `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
 |
 |      This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
 |      any kwargs passed to the class definition that aren't used internally by Pydantic.
 |
 |      Args:
 |          **kwargs: Any keyword arguments passed to the class definition that aren't used internally
 |              by Pydantic.
 |
 |      Note:
 |          You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
 |          instead, which is called once the class and its fields are fully initialized and ready for validation.
 |
 |  __pydantic_on_complete__() -> 'None'
 |      This is called once the class and its fields are fully initialized and ready to be used.
 |
 |      This typically happens when the class is created (just before
 |      [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
 |      except when forward annotations are used that could not immediately be resolved.
 |      In that case, it will be called later, when the model is rebuilt automatically or explicitly using
 |      [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
 |
 |  construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
 |
 |  from_orm(obj: 'Any') -> 'Self'
 |
 |  model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
 |      Generates a JSON schema for a model class.
 |
 |      Args:
 |          by_alias: Whether to use attribute aliases or not.
 |          ref_template: The reference template.
 |          union_format: The format to use when combining schemas from unions together. Can be one of:
 |
 |              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
 |              keyword to combine schemas (the default).
 |              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
 |              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
 |              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
 |              `any_of`.
 |          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
 |              `GenerateJsonSchema` with your desired modifications
 |          mode: The mode in which to generate the schema.
 |
 |      Returns:
 |          The JSON schema for the given model class.
 |
 |  model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
 |      Compute the class name for parametrizations of generic classes.
 |
 |      This method can be overridden to achieve a custom naming scheme for generic BaseModels.
 |
 |      Args:
 |          params: Tuple of types of the class. Given a generic class
 |              `Model` with 2 type variables and a concrete model `Model[str, int]`,
 |              the value `(str, int)` would be passed to `params`.
 |
 |      Returns:
 |          String representing the new class where `params` are passed to `cls` as type variables.
 |
 |      Raises:
 |          TypeError: Raised when trying to generate concrete names for non-generic models.
 |
 |  model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
 |      Try to rebuild the pydantic-core schema for the model.
 |
 |      This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
 |      the initial attempt to build the schema, and automatic rebuilding fails.
 |
 |      Args:
 |          force: Whether to force the rebuilding of the model schema, defaults to `False`.
 |          raise_errors: Whether to raise errors, defaults to `True`.
 |          _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
 |          _types_namespace: The types namespace, defaults to `None`.
 |
 |      Returns:
 |          Returns `None` if the schema is already "complete" and rebuilding was not required.
 |          If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
 |
 |  model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      Validate a pydantic model instance.
 |
 |      Args:
 |          obj: The object to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          from_attributes: Whether to extract data from object attributes.
 |          context: Additional context to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Raises:
 |          ValidationError: If the object could not be validated.
 |
 |      Returns:
 |          The validated model instance.
 |
 |  model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      !!! abstract "Usage Documentation"
 |          [JSON Parsing](../concepts/json.md#json-parsing)
 |
 |      Validate the given JSON data against the Pydantic model.
 |
 |      Args:
 |          json_data: The JSON data to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Extra variables to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated Pydantic model.
 |
 |      Raises:
 |          ValidationError: If `json_data` is not a JSON string or the object could not be validated.
 |
 |  model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
 |      Validate the given object with string data against the Pydantic model.
 |
 |      Args:
 |          obj: The object containing string data to validate.
 |          strict: Whether to enforce types strictly.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Extra variables to pass to the validator.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated Pydantic model.
 |
 |  parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
 |
 |  parse_obj(obj: 'Any') -> 'Self'
 |
 |  parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
 |
 |  schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
 |
 |  schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
 |
 |  update_forward_refs(**localns: 'Any') -> 'None'
 |
 |  validate(value: 'Any') -> 'Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from pydantic.main.BaseModel:
 |
 |  __fields_set__
 |
 |  model_extra
 |      Get extra fields set during validation.
 |
 |      Returns:
 |          A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
 |
 |  model_fields_set
 |      Returns the set of fields that have been explicitly set on this model instance.
 |
 |      Returns:
 |          A set of strings representing the fields that have been set,
 |              i.e. that were not filled from defaults.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pydantic.main.BaseModel:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __pydantic_fields_set__
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from pydantic.main.BaseModel:
 |
 |  model_computed_fields = {}
 |
 |  model_fields = {'root': FieldInfo(annotation=TypeVar, required=True)}

Python Library Documentation: class Secret in module pydantic.types

class Secret(_SecretBase)
 |  Secret(secret_value: 'SecretType') -> 'None'
 |
 |  A generic base class used for defining a field with sensitive information that you do not want to be visible in logging or tracebacks.
 |
 |  You may either directly parametrize `Secret` with a type, or subclass from `Secret` with a parametrized type. The benefit of subclassing
 |  is that you can define a custom `_display` method, which will be used for `repr()` and `str()` methods. The examples below demonstrate both
 |  ways of using `Secret` to create a new secret type.
 |
 |  1. Directly parametrizing `Secret` with a type:
 |
 |  ```python
 |  from pydantic import BaseModel, Secret
 |
 |  SecretBool = Secret[bool]
 |
 |  class Model(BaseModel):
 |      secret_bool: SecretBool
 |
 |  m = Model(secret_bool=True)
 |  print(m.model_dump())
 |  #> {'secret_bool': Secret('**********')}
 |
 |  print(m.model_dump_json())
 |  #> {"secret_bool":"**********"}
 |
 |  print(m.secret_bool.get_secret_value())
 |  #> True
 |  ```
 |
 |  2. Subclassing from parametrized `Secret`:
 |
 |  ```python
 |  from datetime import date
 |
 |  from pydantic import BaseModel, Secret
 |
 |  class SecretDate(Secret[date]):
 |      def _display(self) -> str:
 |          return '****/**/**'
 |
 |  class Model(BaseModel):
 |      secret_date: SecretDate
 |
 |  m = Model(secret_date=date(2022, 1, 1))
 |  print(m.model_dump())
 |  #> {'secret_date': SecretDate('****/**/**')}
 |
 |  print(m.model_dump_json())
 |  #> {"secret_date":"****/**/**"}
 |
 |  print(m.secret_date.get_secret_value())
 |  #> 2022-01-01
 |  ```
 |
 |  The value returned by the `_display` method will be used for `repr()` and `str()`.
 |
 |  You can enforce constraints on the underlying type through annotations:
 |  For example:
 |
 |  ```python
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, Field, Secret, ValidationError
 |
 |  SecretPosInt = Secret[Annotated[int, Field(gt=0, strict=True)]]
 |
 |  class Model(BaseModel):
 |      sensitive_int: SecretPosInt
 |
 |  m = Model(sensitive_int=42)
 |  print(m.model_dump())
 |  #> {'sensitive_int': Secret('**********')}
 |
 |  try:
 |      m = Model(sensitive_int=-42)  # (1)!
 |  except ValidationError as exc_info:
 |      print(exc_info.errors(include_url=False, include_input=False))
 |      '''
 |      [
 |          {
 |              'type': 'greater_than',
 |              'loc': ('sensitive_int',),
 |              'msg': 'Input should be greater than 0',
 |              'ctx': {'gt': 0},
 |          }
 |      ]
 |      '''
 |
 |  try:
 |      m = Model(sensitive_int='42')  # (2)!
 |  except ValidationError as exc_info:
 |      print(exc_info.errors(include_url=False, include_input=False))
 |      '''
 |      [
 |          {
 |              'type': 'int_type',
 |              'loc': ('sensitive_int',),
 |              'msg': 'Input should be a valid integer',
 |          }
 |      ]
 |      '''
 |  ```
 |
 |  1. The input value is not greater than 0, so it raises a validation error.
 |  2. The input value is not an integer, so it raises a validation error because the `SecretPosInt` type has strict mode enabled.
 |
 |  Method resolution order:
 |      Secret
 |      _SecretBase
 |      typing.Generic
 |      builtins.object
 |
 |  Class methods defined here:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  __orig_bases__ = (pydantic.types._SecretBase[+SecretType],)
 |
 |  __parameters__ = (+SecretType,)
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=Function(
 |      Fu...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _SecretBase:
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, secret_value: 'SecretType') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  get_secret_value(self) -> 'SecretType'
 |      Get the secret value.
 |
 |      Returns:
 |          The secret value.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _SecretBase:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  __init_subclass__(...)
 |      Function to initialize subclasses.

Python Library Documentation: class SecretBytes in module pydantic.types

class SecretBytes(_SecretField)
 |  SecretBytes(secret_value: 'SecretType') -> 'None'
 |
 |  A bytes used for storing sensitive information that you do not want to be visible in logging or tracebacks.
 |
 |  It displays `b'**********'` instead of the string value on `repr()` and `str()` calls.
 |  When the secret value is nonempty, it is displayed as `b'**********'` instead of the underlying value in
 |  calls to `repr()` and `str()`. If the value _is_ empty, it is displayed as `b''`.
 |
 |  ```python
 |  from pydantic import BaseModel, SecretBytes
 |
 |  class User(BaseModel):
 |      username: str
 |      password: SecretBytes
 |
 |  user = User(username='scolvin', password=b'password1')
 |  #> username='scolvin' password=SecretBytes(b'**********')
 |  print(user.password.get_secret_value())
 |  #> b'password1'
 |  print((SecretBytes(b'password'), SecretBytes(b'')))
 |  #> (SecretBytes(b'**********'), SecretBytes(b''))
 |  ```
 |
 |  Method resolution order:
 |      SecretBytes
 |      _SecretField
 |      _SecretBase
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __len__(self) -> 'int'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_error_kind': 'ClassVar[str]', '_inner_schema': 'C...
 |
 |  __orig_bases__ = (pydantic.types._SecretField[bytes],)
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _SecretField:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _SecretField:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=Function(
 |      Fu...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _SecretBase:
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, secret_value: 'SecretType') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  get_secret_value(self) -> 'SecretType'
 |      Get the secret value.
 |
 |      Returns:
 |          The secret value.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _SecretBase:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  __init_subclass__(...)
 |      Function to initialize subclasses.

Python Library Documentation: class SecretStr in module pydantic.types

class SecretStr(_SecretField)
 |  SecretStr(secret_value: 'SecretType') -> 'None'
 |
 |  A string used for storing sensitive information that you do not want to be visible in logging or tracebacks.
 |
 |  When the secret value is nonempty, it is displayed as `'**********'` instead of the underlying value in
 |  calls to `repr()` and `str()`. If the value _is_ empty, it is displayed as `''`.
 |
 |  ```python
 |  from pydantic import BaseModel, SecretStr
 |
 |  class User(BaseModel):
 |      username: str
 |      password: SecretStr
 |
 |  user = User(username='scolvin', password='password1')
 |
 |  print(user)
 |  #> username='scolvin' password=SecretStr('**********')
 |  print(user.password.get_secret_value())
 |  #> password1
 |  print((SecretStr('password'), SecretStr('')))
 |  #> (SecretStr('**********'), SecretStr(''))
 |  ```
 |
 |  As seen above, by default, [`SecretStr`][pydantic.types.SecretStr] (and [`SecretBytes`][pydantic.types.SecretBytes])
 |  will be serialized as `**********` when serializing to json.
 |
 |  You can use the [`field_serializer`][pydantic.functional_serializers.field_serializer] to dump the
 |  secret as plain-text when serializing to json.
 |
 |  ```python
 |  from pydantic import BaseModel, SecretBytes, SecretStr, field_serializer
 |
 |  class Model(BaseModel):
 |      password: SecretStr
 |      password_bytes: SecretBytes
 |
 |      @field_serializer('password', 'password_bytes', when_used='json')
 |      def dump_secret(self, v):
 |          return v.get_secret_value()
 |
 |  model = Model(password='IAmSensitive', password_bytes=b'IAmSensitiveBytes')
 |  print(model)
 |  #> password=SecretStr('**********') password_bytes=SecretBytes(b'**********')
 |  print(model.password)
 |  #> **********
 |  print(model.model_dump())
 |  '''
 |  {
 |      'password': SecretStr('**********'),
 |      'password_bytes': SecretBytes(b'**********'),
 |  }
 |  '''
 |  print(model.model_dump_json())
 |  #> {"password":"IAmSensitive","password_bytes":"IAmSensitiveBytes"}
 |  ```
 |
 |  Method resolution order:
 |      SecretStr
 |      _SecretField
 |      _SecretBase
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __len__(self) -> 'int'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_error_kind': 'ClassVar[str]', '_inner_schema': 'C...
 |
 |  __orig_bases__ = (pydantic.types._SecretField[str],)
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _SecretField:
 |
 |  __get_pydantic_core_schema__(source: 'type[Any]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _SecretField:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=Function(
 |      Fu...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _SecretBase:
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, secret_value: 'SecretType') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  get_secret_value(self) -> 'SecretType'
 |      Get the secret value.
 |
 |      Returns:
 |          The secret value.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _SecretBase:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  __init_subclass__(...)
 |      Function to initialize subclasses.

Python Library Documentation: class SerializationInfo in module pydantic_core.core_schema

class SerializationInfo(typing.Protocol)
 |  SerializationInfo(*args, **kwargs)
 |
 |  Extra data used during serialization.
 |
 |  Method resolution order:
 |      SerializationInfo
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  mode_is_json(self) -> 'bool'
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  by_alias
 |      The `by_alias` argument set during serialization.
 |
 |  context
 |      The current serialization context.
 |
 |  exclude
 |      The `exclude` argument set during serialization.
 |
 |  exclude_computed_fields
 |      The `exclude_computed_fields` argument set during serialization.
 |
 |  exclude_defaults
 |      The `exclude_defaults` argument set during serialization.
 |
 |  exclude_none
 |      The `exclude_none` argument set during serialization.
 |
 |  exclude_unset
 |      The `exclude_unset` argument set during serialization.
 |
 |  include
 |      The `include` argument set during serialization.
 |
 |  mode
 |      The serialization mode set during serialization.
 |
 |  polymorphic_serialization
 |      The `polymorphic_serialization` argument set during serialization, if any.
 |
 |  round_trip
 |      The `round_trip` argument set during serialization.
 |
 |  serialize_as_any
 |      The `serialize_as_any` argument set during serialization.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __orig_bases__ = (typing.Protocol[+ContextT],)
 |
 |  __parameters__ = (+ContextT,)
 |
 |  __protocol_attrs__ = {'__repr__', '__str__', 'by_alias', 'context', 'e...
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class SerializeAsAny in module pydantic.functional_serializers

class SerializeAsAny(builtins.object)
 |  SerializeAsAny() -> None
 |
 |  Annotation used to mark a type as having duck-typing serialization behavior.
 |
 |  See [usage documentation](../concepts/serialization.md#serializing-with-duck-typing) for more details.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __hash__(self, /) from builtins.object
 |      Return hash(self).
 |
 |  __init__(self) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(item: 'Any') -> 'Any'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __dataclass_fields__ = {}
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ()

Python Library Documentation: class SerializerFunctionWrapHandler in module pydantic_core.core_schema

class SerializerFunctionWrapHandler(typing.Protocol)
 |  SerializerFunctionWrapHandler(*args, **kwargs)
 |
 |  Method resolution order:
 |      SerializerFunctionWrapHandler
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, input_value: 'Any', index_key: 'int | str | None' = None, /) -> 'Any'
 |      Call self as a function.
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __parameters__ = ()
 |
 |  __protocol_attrs__ = {'__call__'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class SkipValidation in module pydantic.functional_validators

class SkipValidation(builtins.object)
 |  SkipValidation() -> None
 |
 |  If this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be
 |      skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`.
 |
 |  This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes,
 |  and know that it is safe to skip validation for one or more of the fields.
 |
 |  Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations
 |  may not have the expected effects. Therefore, when used, this annotation should generally be the final
 |  annotation applied to a type.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self, /) from builtins.object
 |      Return hash(self).
 |
 |  __init__(self) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(item: 'Any') -> 'Any'
 |
 |  __get_pydantic_core_schema__(source: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __dataclass_fields__ = {}
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ()

Python Library Documentation: class SnowflakeDsn in module pydantic.networks

class SnowflakeDsn(AnyUrl)
 |  SnowflakeDsn(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any Snowflake DSN.
 |
 |  * User info required
 |  * TLD not required
 |  * Host required
 |
 |  Method resolution order:
 |      SnowflakeDsn
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Readonly properties defined here:
 |
 |  host
 |      The required URL host.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class Path(PurePath)
 |  Annotated(*args, **kwargs)
 |
 |  PurePath subclass that can make system calls.
 |
 |  Path represents a filesystem path but unlike PurePath, also offers
 |  methods to do system calls on path objects. Depending on your system,
 |  instantiating a Path will return either a PosixPath or a WindowsPath
 |  object. You can also instantiate a PosixPath or WindowsPath directly,
 |  but cannot instantiate a WindowsPath on a POSIX system or vice versa.
 |
 |  Method resolution order:
 |      Path
 |      PurePath
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, t, v, tb)
 |
 |  __init__(self, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  absolute(self)
 |      Return an absolute version of this path by prepending the current
 |      working directory. No normalization or symlink resolution is performed.
 |
 |      Use resolve() to get the canonical path to a file.
 |
 |  chmod(self, mode, *, follow_symlinks=True)
 |      Change the permissions of the path, like os.chmod().
 |
 |  exists(self, *, follow_symlinks=True)
 |      Whether this path exists.
 |
 |      This method normally follows symlinks; to check whether a symlink exists,
 |      add the argument follow_symlinks=False.
 |
 |  expanduser(self)
 |      Return a new path with expanded ~ and ~user constructs
 |      (as returned by os.path.expanduser)
 |
 |  glob(self, pattern, *, case_sensitive=None)
 |      Iterate over this subtree and yield all existing files (of any
 |      kind, including directories) matching the given relative pattern.
 |
 |  group(self)
 |      Return the group name of the file gid.
 |
 |  hardlink_to(self, target)
 |      Make this path a hard link pointing to the same file as *target*.
 |
 |      Note the order of arguments (self, target) is the reverse of os.link's.
 |
 |  is_block_device(self)
 |      Whether this path is a block device.
 |
 |  is_char_device(self)
 |      Whether this path is a character device.
 |
 |  is_dir(self)
 |      Whether this path is a directory.
 |
 |  is_fifo(self)
 |      Whether this path is a FIFO.
 |
 |  is_file(self)
 |      Whether this path is a regular file (also True for symlinks pointing
 |      to regular files).
 |
 |  is_junction(self)
 |      Whether this path is a junction.
 |
 |  is_mount(self)
 |      Check if this path is a mount point
 |
 |  is_socket(self)
 |      Whether this path is a socket.
 |
 |  is_symlink(self)
 |      Whether this path is a symbolic link.
 |
 |  iterdir(self)
 |      Yield path objects of the directory contents.
 |
 |      The children are yielded in arbitrary order, and the
 |      special entries '.' and '..' are not included.
 |
 |  lchmod(self, mode)
 |      Like chmod(), except if the path points to a symlink, the symlink's
 |      permissions are changed, rather than its target's.
 |
 |  lstat(self)
 |      Like stat(), except if the path points to a symlink, the symlink's
 |      status information is returned, rather than its target's.
 |
 |  mkdir(self, mode=511, parents=False, exist_ok=False)
 |      Create a new directory at this given path.
 |
 |  open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
 |      Open the file pointed to by this path and return a file object, as
 |      the built-in open() function does.
 |
 |  owner(self)
 |      Return the login name of the file owner.
 |
 |  read_bytes(self)
 |      Open the file in bytes mode, read it, and close the file.
 |
 |  read_text(self, encoding=None, errors=None)
 |      Open the file in text mode, read it, and close the file.
 |
 |  readlink(self)
 |      Return the path to which the symbolic link points.
 |
 |  rename(self, target)
 |      Rename this path to the target path.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  replace(self, target)
 |      Rename this path to the target path, overwriting if that path exists.
 |
 |      The target path may be absolute or relative. Relative paths are
 |      interpreted relative to the current working directory, *not* the
 |      directory of the Path object.
 |
 |      Returns the new Path instance pointing to the target path.
 |
 |  resolve(self, strict=False)
 |      Make the path absolute, resolving all symlinks on the way and also
 |      normalizing it.
 |
 |  rglob(self, pattern, *, case_sensitive=None)
 |      Recursively yield all existing files (of any kind, including
 |      directories) matching the given relative pattern, anywhere in
 |      this subtree.
 |
 |  rmdir(self)
 |      Remove this directory.  The directory must be empty.
 |
 |  samefile(self, other_path)
 |      Return whether other_path is the same or not as this file
 |      (as returned by os.path.samefile()).
 |
 |  stat(self, *, follow_symlinks=True)
 |      Return the result of the stat() system call on this path, like
 |      os.stat() does.
 |
 |  symlink_to(self, target, target_is_directory=False)
 |      Make this path a symlink pointing to the target path.
 |      Note the order of arguments (link, target) is the reverse of os.symlink.
 |
 |  touch(self, mode=438, exist_ok=True)
 |      Create this file with the given access mode, if it doesn't exist.
 |
 |  unlink(self, missing_ok=False)
 |      Remove this file or link.
 |      If the path is a directory, use rmdir() instead.
 |
 |  walk(self, top_down=True, on_error=None, follow_symlinks=False)
 |      Walk the directory tree from this directory, similar to os.walk().
 |
 |  write_bytes(self, data)
 |      Open the file in bytes mode, write to it, and close the file.
 |
 |  write_text(self, data, encoding=None, errors=None, newline=None)
 |      Open the file in text mode, write to it, and close the file.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  cwd()
 |      Return a new path pointing to the current working directory.
 |
 |  home()
 |      Return a new path pointing to the user's home directory (as
 |      returned by os.path.expanduser('~')).
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(cls, *args, **kwargs)
 |      Construct a PurePath from one or several strings and or existing
 |      PurePath objects.  The strings and path objects are combined so as
 |      to yield a canonicalized path, which is incorporated into the
 |      new PurePath object.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from PurePath:
 |
 |  __bytes__(self)
 |      Return the bytes representation of the path.  This is only
 |      recommended to use under Unix.
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __fspath__(self)
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __reduce__(self)
 |      Helper for pickle.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __rtruediv__(self, key)
 |
 |  __str__(self)
 |      Return the string representation of the path, suitable for
 |      passing to system calls.
 |
 |  __truediv__(self, key)
 |
 |  as_posix(self)
 |      Return the string representation of the path with forward (/)
 |      slashes.
 |
 |  as_uri(self)
 |      Return the path as a 'file' URI.
 |
 |  is_absolute(self)
 |      True if the path is absolute (has both a root and, if applicable,
 |      a drive).
 |
 |  is_relative_to(self, other, /, *_deprecated)
 |      Return True if the path is relative to another path or False.
 |
 |  is_reserved(self)
 |      Return True if the path contains one of the special names reserved
 |      by the system, if any.
 |
 |  joinpath(self, *pathsegments)
 |      Combine this path with one or several arguments, and return a
 |      new path representing either a subpath (if all arguments are relative
 |      paths) or a totally different path (if one of the arguments is
 |      anchored).
 |
 |  match(self, path_pattern, *, case_sensitive=None)
 |      Return True if this path matches the given pattern.
 |
 |  relative_to(self, other, /, *_deprecated, walk_up=False)
 |      Return the relative path to another path identified by the passed
 |      arguments.  If the operation is not possible (because this is not
 |      related to the other path), raise ValueError.
 |
 |      The *walk_up* parameter controls whether `..` may be used to resolve
 |      the path.
 |
 |  with_name(self, name)
 |      Return a new path with the file name changed.
 |
 |  with_segments(self, *pathsegments)
 |      Construct a new path object from any number of path-like objects.
 |      Subclasses may override this method to customize how new path objects
 |      are created from methods like `iterdir()`.
 |
 |  with_stem(self, stem)
 |      Return a new path with the stem changed.
 |
 |  with_suffix(self, suffix)
 |      Return a new path with the file suffix changed.  If the path
 |      has no suffix, add given suffix.  If the given suffix is an empty
 |      string, remove the suffix from the path.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from PurePath:
 |
 |  anchor
 |      The concatenation of the drive and root, or ''.
 |
 |  drive
 |      The drive prefix (letter or UNC path), if any.
 |
 |  name
 |      The final path component, if any.
 |
 |  parent
 |      The logical parent of the path.
 |
 |  parents
 |      A sequence of this path's logical parents.
 |
 |  parts
 |      An object providing sequence-like access to the
 |      components in the filesystem path.
 |
 |  root
 |      The root of the path, if any.
 |
 |  stem
 |      The final path component, minus its last suffix.
 |
 |  suffix
 |      The final component's last suffix, if any.
 |
 |      This includes the leading period. For example: '.txt'
 |
 |  suffixes
 |      A list of the final component's suffixes, if any.
 |
 |      These include the leading periods. For example: ['.tar', '.gz']

Python Library Documentation: class Strict in module pydantic.types

class Strict(pydantic._internal._fields.PydanticMetadata, annotated_types.BaseMetadata)
 |  Strict(strict: 'bool' = True) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [Strict Mode with `Annotated` `Strict`](../concepts/strict_mode.md#strict-mode-with-annotated-strict)
 |
 |  A field metadata class to indicate that a field should be validated in strict mode.
 |  Use this class as an annotation via [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated), as seen below.
 |
 |  Attributes:
 |      strict: Whether to validate the field in strict mode.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic.types import Strict
 |
 |      StrictBool = Annotated[bool, Strict()]
 |      ```
 |
 |  Method resolution order:
 |      Strict
 |      pydantic._internal._fields.PydanticMetadata
 |      pydantic._internal._repr.Representation
 |      annotated_types.BaseMetadata
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, strict: 'bool' = True) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'strict': 'bool'}
 |
 |  __dataclass_fields__ = {'strict': Field(name='strict',type='bool',defa...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('strict',)
 |
 |  strict = True
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from pydantic._internal._repr.Representation:
 |
 |  __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]'
 |      Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
 |
 |  __repr_args__(self) -> 'ReprArgs'
 |      Returns the attributes to show in __str__, __repr__, and __pretty__ this is generally overridden.
 |
 |      Can either return:
 |      * name - value pairs, e.g.: `[('foo_name', 'foo'), ('bar_name', ['b', 'a', 'r'])]`
 |      * or, just values, e.g.: `[(None, 'foo'), (None, ['b', 'a', 'r'])]`
 |
 |  __repr_name__(self) -> 'str'
 |      Name of the instance's class, used in __repr__.
 |
 |  __repr_recursion__(self, object: 'Any') -> 'str'
 |      Returns the string representation of a recursive object.
 |
 |  __repr_str__(self, join_str: 'str') -> 'str'
 |
 |  __rich_repr__(self) -> 'RichReprResult'
 |      Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
 |
 |  __str__(self) -> 'str'
 |      Return str(self).

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class bool(int)
 |  bool(x) -> bool
 |
 |  Returns True when the argument x is true, False otherwise.
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |
 |  Methods defined here:
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from int:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from int:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from int:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class bytes(object)
 |  bytes(iterable_of_ints) -> bytes
 |  bytes(string, encoding[, errors]) -> bytes
 |  bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
 |  bytes(int) -> bytes object of size given by the parameter initialized with null bytes
 |  bytes() -> empty bytes object
 |
 |  Construct an immutable array of bytes from:
 |    - an iterable yielding integers in range(256)
 |    - a text string encoded using the specified encoding
 |    - any object implementing the buffer API.
 |    - an integer
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __buffer__(self, flags, /)
 |      Return a buffer object that exposes the underlying memory of the object.
 |
 |  __bytes__(self, /)
 |      Convert this value to exact type bytes.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(...)
 |      B.capitalize() -> copy of B
 |
 |      Return a copy of B with only its first character capitalized (ASCII)
 |      and the rest lower-cased.
 |
 |  center(self, width, fillchar=b' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  count(...)
 |      B.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of subsection sub in
 |      bytes B[start:end].  Optional arguments start and end are interpreted
 |      as in slice notation.
 |
 |  decode(self, /, encoding='utf-8', errors='strict')
 |      Decode the bytes using the codec registered for encoding.
 |
 |      encoding
 |        The encoding with which to decode the bytes.
 |      errors
 |        The error handling scheme to use for the handling of decoding errors.
 |        The default is 'strict' meaning that decoding errors raise a
 |        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
 |        as well as any other name registered with codecs.register_error that
 |        can handle UnicodeDecodeErrors.
 |
 |  endswith(...)
 |      B.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if B ends with the specified suffix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      suffix can also be a tuple of bytes to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      B.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  hex(...)
 |      Create a string of hexadecimal numbers from a bytes object.
 |
 |        sep
 |          An optional single character or byte to separate hex bytes.
 |        bytes_per_sep
 |          How many bytes between separators.  Positive values count from the
 |          right, negative values count from the left.
 |
 |      Example:
 |      >>> value = b'\xb9\x01\xef'
 |      >>> value.hex()
 |      'b901ef'
 |      >>> value.hex(':')
 |      'b9:01:ef'
 |      >>> value.hex(':', 2)
 |      'b9:01ef'
 |      >>> value.hex(':', -2)
 |      'b901:ef'
 |
 |  index(...)
 |      B.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the subsection is not found.
 |
 |  isalnum(...)
 |      B.isalnum() -> bool
 |
 |      Return True if all characters in B are alphanumeric
 |      and there is at least one character in B, False otherwise.
 |
 |  isalpha(...)
 |      B.isalpha() -> bool
 |
 |      Return True if all characters in B are alphabetic
 |      and there is at least one character in B, False otherwise.
 |
 |  isascii(...)
 |      B.isascii() -> bool
 |
 |      Return True if B is empty or all characters in B are ASCII,
 |      False otherwise.
 |
 |  isdigit(...)
 |      B.isdigit() -> bool
 |
 |      Return True if all characters in B are digits
 |      and there is at least one character in B, False otherwise.
 |
 |  islower(...)
 |      B.islower() -> bool
 |
 |      Return True if all cased characters in B are lowercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  isspace(...)
 |      B.isspace() -> bool
 |
 |      Return True if all characters in B are whitespace
 |      and there is at least one character in B, False otherwise.
 |
 |  istitle(...)
 |      B.istitle() -> bool
 |
 |      Return True if B is a titlecased string and there is at least one
 |      character in B, i.e. uppercase characters may only follow uncased
 |      characters and lowercase characters only cased ones. Return False
 |      otherwise.
 |
 |  isupper(...)
 |      B.isupper() -> bool
 |
 |      Return True if all cased characters in B are uppercase and there is
 |      at least one cased character in B, False otherwise.
 |
 |  join(self, iterable_of_bytes, /)
 |      Concatenate any number of bytes objects.
 |
 |      The bytes whose method is called is inserted in between each pair.
 |
 |      The result is returned as a new bytes object.
 |
 |      Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
 |
 |  ljust(self, width, fillchar=b' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  lower(...)
 |      B.lower() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to lowercase.
 |
 |  lstrip(self, bytes=None, /)
 |      Strip leading bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading  ASCII whitespace.
 |
 |  partition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes. If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original bytes
 |      object and two empty bytes objects.
 |
 |  removeprefix(self, prefix, /)
 |      Return a bytes object with the given prefix string removed if present.
 |
 |      If the bytes starts with the prefix string, return bytes[len(prefix):].
 |      Otherwise, return a copy of the original bytes.
 |
 |  removesuffix(self, suffix, /)
 |      Return a bytes object with the given suffix string removed if present.
 |
 |      If the bytes ends with the suffix string and that suffix is not empty,
 |      return bytes[:-len(prefix)].  Otherwise, return a copy of the original
 |      bytes.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      B.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      B.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in B where subsection sub is found,
 |      such that sub is contained within B[start,end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raise ValueError when the subsection is not found.
 |
 |  rjust(self, width, fillchar=b' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character.
 |
 |  rpartition(self, sep, /)
 |      Partition the bytes into three parts using the given separator.
 |
 |      This will search for the separator sep in the bytes, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty bytes
 |      objects and the original bytes object.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |        sep
 |          The delimiter according which to split the bytes.
 |          None (the default value) means split on ASCII whitespace characters
 |          (space, tab, return, newline, formfeed, vertical tab).
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |
 |      Splitting is done starting at the end of the bytes and working to the front.
 |
 |  rstrip(self, bytes=None, /)
 |      Strip trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip trailing ASCII whitespace.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the sections in the bytes, using sep as the delimiter.
 |
 |      sep
 |        The delimiter according which to split the bytes.
 |        None (the default value) means split on ASCII whitespace characters
 |        (space, tab, return, newline, formfeed, vertical tab).
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the bytes, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      B.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if B starts with the specified prefix, False otherwise.
 |      With optional start, test B beginning at that position.
 |      With optional end, stop comparing B at that position.
 |      prefix can also be a tuple of bytes to try.
 |
 |  strip(self, bytes=None, /)
 |      Strip leading and trailing bytes contained in the argument.
 |
 |      If the argument is omitted or None, strip leading and trailing ASCII whitespace.
 |
 |  swapcase(...)
 |      B.swapcase() -> copy of B
 |
 |      Return a copy of B with uppercase ASCII characters converted
 |      to lowercase ASCII and vice versa.
 |
 |  title(...)
 |      B.title() -> copy of B
 |
 |      Return a titlecased version of B, i.e. ASCII words start with uppercase
 |      characters, all remaining cased characters have lowercase.
 |
 |  translate(self, table, /, delete=b'')
 |      Return a copy with each character mapped by the given translation table.
 |
 |        table
 |          Translation table, which must be a bytes object of length 256.
 |
 |      All characters occurring in the optional argument delete are removed.
 |      The remaining characters are mapped through the given translation table.
 |
 |  upper(...)
 |      B.upper() -> copy of B
 |
 |      Return a copy of B with all ASCII characters converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The original string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  fromhex(string, /)
 |      Create a bytes object from a string of hexadecimal numbers.
 |
 |      Spaces between two numbers are accepted.
 |      Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(frm, to, /)
 |      Return a translation table useable for the bytes or bytearray translate method.
 |
 |      The returned table will be one where each byte in frm is mapped to the byte at
 |      the same position in to.
 |
 |      The bytes objects frm and to must be of the same length.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class float(object)
 |  Annotated(x=0, /)
 |
 |  Convert a string or number to a floating-point number, if possible.
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(self, /)
 |      Return the ceiling as an Integral.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(self, /)
 |      Return the floor as an Integral.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Formats the float according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __round__(self, ndigits=None, /)
 |      Return the Integral closest to x, rounding half toward even.
 |
 |      When an argument is passed, work like built-in round(x, ndigits).
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(self, /)
 |      Return the Integral closest to x between 0 and x.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is exactly equal to the original float.
 |
 |      The ratio is in lowest terms and has a positive denominator.  Raise
 |      OverflowError on infinities and a ValueError on NaNs.
 |
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)
 |
 |  conjugate(self, /)
 |      Return self, the complex conjugate of any float.
 |
 |  hex(self, /)
 |      Return a hexadecimal representation of a floating-point number.
 |
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'
 |
 |  is_integer(self, /)
 |      Return True if the float is an integer.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __getformat__(typestr, /)
 |      You probably don't want to use this function.
 |
 |        typestr
 |          Must be 'double' or 'float'.
 |
 |      It exists mainly to be used in Python's test suite.
 |
 |      This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
 |      little-endian' best describes the format of floating-point numbers used by the
 |      C type named by typestr.
 |
 |  fromhex(string, /)
 |      Create a floating-point number from a hexadecimal string.
 |
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -5e-324
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class int(object)
 |  int([x]) -> integer
 |  int(x, base=10) -> integer
 |
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating-point
 |  numbers, this truncates towards zero.
 |
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |
 |  Built-in subclasses:
 |      bool
 |
 |  Methods defined here:
 |
 |  __abs__(self, /)
 |      abs(self)
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __and__(self, value, /)
 |      Return self&value.
 |
 |  __bool__(self, /)
 |      True if self else False
 |
 |  __ceil__(...)
 |      Ceiling of an Integral returns itself.
 |
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __float__(self, /)
 |      float(self)
 |
 |  __floor__(...)
 |      Flooring an Integral returns itself.
 |
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |
 |  __format__(self, format_spec, /)
 |      Convert to a string according to format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |
 |  __int__(self, /)
 |      int(self)
 |
 |  __invert__(self, /)
 |      ~self
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __neg__(self, /)
 |      -self
 |
 |  __or__(self, value, /)
 |      Return self|value.
 |
 |  __pos__(self, /)
 |      +self
 |
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |
 |  __radd__(self, value, /)
 |      Return value+self.
 |
 |  __rand__(self, value, /)
 |      Return value&self.
 |
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __ror__(self, value, /)
 |      Return value|self.
 |
 |  __round__(...)
 |      Rounding an Integral returns itself.
 |
 |      Rounding with an ndigits argument also returns an integer.
 |
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |
 |  __rsub__(self, value, /)
 |      Return value-self.
 |
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |
 |  __rxor__(self, value, /)
 |      Return value^self.
 |
 |  __sizeof__(self, /)
 |      Returns size in memory, in bytes.
 |
 |  __sub__(self, value, /)
 |      Return self-value.
 |
 |  __truediv__(self, value, /)
 |      Return self/value.
 |
 |  __trunc__(...)
 |      Truncating an Integral returns itself.
 |
 |  __xor__(self, value, /)
 |      Return self^value.
 |
 |  as_integer_ratio(self, /)
 |      Return a pair of integers, whose ratio is equal to the original int.
 |
 |      The ratio is in lowest terms and has a positive denominator.
 |
 |      >>> (10).as_integer_ratio()
 |      (10, 1)
 |      >>> (-10).as_integer_ratio()
 |      (-10, 1)
 |      >>> (0).as_integer_ratio()
 |      (0, 1)
 |
 |  bit_count(self, /)
 |      Number of ones in the binary representation of the absolute value of self.
 |
 |      Also known as the population count.
 |
 |      >>> bin(13)
 |      '0b1101'
 |      >>> (13).bit_count()
 |      3
 |
 |  bit_length(self, /)
 |      Number of bits necessary to represent self in binary.
 |
 |      >>> bin(37)
 |      '0b100101'
 |      >>> (37).bit_length()
 |      6
 |
 |  conjugate(...)
 |      Returns self, the complex conjugate of any int.
 |
 |  is_integer(self, /)
 |      Returns True. Exists for duck type compatibility with float.is_integer.
 |
 |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
 |      Return an array of bytes representing an integer.
 |
 |      length
 |        Length of bytes object to use.  An OverflowError is raised if the
 |        integer is not representable with the given number of bytes.  Default
 |        is length 1.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Determines whether two's complement is used to represent the integer.
 |        If signed is False and a negative integer is given, an OverflowError
 |        is raised.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_bytes(bytes, byteorder='big', *, signed=False)
 |      Return the integer represented by the given array of bytes.
 |
 |      bytes
 |        Holds the array of bytes to convert.  The argument must either
 |        support the buffer protocol or be an iterable object producing bytes.
 |        Bytes and bytearray are examples of built-in objects that support the
 |        buffer protocol.
 |      byteorder
 |        The byte order used to represent the integer.  If byteorder is 'big',
 |        the most significant byte is at the beginning of the byte array.  If
 |        byteorder is 'little', the most significant byte is at the end of the
 |        byte array.  To request the native byte order of the host system, use
 |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
 |      signed
 |        Indicates whether two's complement is used to represent the integer.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  denominator
 |      the denominator of a rational number in lowest terms
 |
 |  imag
 |      the imaginary part of a complex number
 |
 |  numerator
 |      the numerator of a rational number in lowest terms
 |
 |  real
 |      the real part of a complex number

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the end of the string and works to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the substrings in the string, using sep as the separator string.
 |
 |        sep
 |          The separator used to split the string.
 |
 |          When set to None (the default value), will split on any whitespace
 |          character (including \n \r \t \f and spaces) and will discard
 |          empty strings from the result.
 |        maxsplit
 |          Maximum number of splits.
 |          -1 (the default value) means no limit.
 |
 |      Splitting starts at the front of the string and works to the end.
 |
 |      Note, str.split() is mainly useful for data that has been intentionally
 |      delimited.  With natural text that includes punctuation, consider using
 |      the regular expression module.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(...)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

Python Library Documentation: class StringConstraints in module pydantic.types

class StringConstraints(annotated_types.GroupedMetadata)
 |  StringConstraints(strip_whitespace: 'bool | None' = None, to_upper: 'bool | None' = None, to_lower: 'bool | None' = None, strict: 'bool | None' = None, min_length: 'int | None' = None, max_length: 'int | None' = None, pattern: 'str | Pattern[str] | None' = None, ascii_only: 'bool | None' = None) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [String types](./standard_library_types.md#strings)
 |
 |  A field metadata class to apply constraints to `str` types.
 |  Use this class as an annotation via [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated), as seen below.
 |
 |  Attributes:
 |      strip_whitespace: Whether to remove leading and trailing whitespace.
 |      to_upper: Whether to convert the string to uppercase.
 |      to_lower: Whether to convert the string to lowercase.
 |      strict: Whether to validate the string in strict mode.
 |      min_length: The minimum length of the string.
 |      max_length: The maximum length of the string.
 |      pattern: A regex pattern that the string must match.
 |      ascii_only: Whether the string should contain only ASCII characters.
 |
 |  Example:
 |      ```python
 |      from typing import Annotated
 |
 |      from pydantic.types import StringConstraints
 |
 |      ConstrainedStr = Annotated[str, StringConstraints(min_length=1, max_length=10)]
 |      ```
 |
 |  Method resolution order:
 |      StringConstraints
 |      annotated_types.GroupedMetadata
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, strip_whitespace: 'bool | None' = None, to_upper: 'bool | None' = None, to_lower: 'bool | None' = None, strict: 'bool | None' = None, min_length: 'int | None' = None, max_length: 'int | None' = None, pattern: 'str | Pattern[str] | None' = None, ascii_only: 'bool | None' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __iter__(self) -> 'Iterator[BaseMetadata]'
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {'ascii_only': 'bool | None', 'max_length': 'int | N...
 |
 |  __dataclass_fields__ = {'ascii_only': Field(name='ascii_only',type='bo...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('strip_whitespace', 'to_upper', 'to_lower', 'strict'...
 |
 |  __parameters__ = ()
 |
 |  ascii_only = None
 |
 |  max_length = None
 |
 |  min_length = None
 |
 |  pattern = None
 |
 |  strict = None
 |
 |  strip_whitespace = None
 |
 |  to_lower = None
 |
 |  to_upper = None
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from annotated_types.GroupedMetadata:
 |
 |  __init_subclass__(*args: Any, **kwargs: Any) -> None
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from annotated_types.GroupedMetadata:
 |
 |  __is_annotated_types_grouped_metadata__
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from annotated_types.GroupedMetadata:
 |
 |  __non_callable_proto_members__ = {'__is_annotated_types_grouped_metada...
 |
 |  __protocol_attrs__ = {'__init_subclass__', '__is_annotated_types_group...
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class Tag in module pydantic.types

class Tag(builtins.object)
 |  Tag(tag: 'str') -> None
 |
 |  Provides a way to specify the expected tag to use for a case of a (callable) discriminated union.
 |
 |  Also provides a way to label a union case in error messages.
 |
 |  When using a callable `Discriminator`, attach a `Tag` to each case in the `Union` to specify the tag that
 |  should be used to identify that case. For example, in the below example, the `Tag` is used to specify that
 |  if `get_discriminator_value` returns `'apple'`, the input should be validated as an `ApplePie`, and if it
 |  returns `'pumpkin'`, the input should be validated as a `PumpkinPie`.
 |
 |  The primary role of the `Tag` here is to map the return value from the callable `Discriminator` function to
 |  the appropriate member of the `Union` in question.
 |
 |  ```python
 |  from typing import Annotated, Any, Literal, Union
 |
 |  from pydantic import BaseModel, Discriminator, Tag
 |
 |  class Pie(BaseModel):
 |      time_to_cook: int
 |      num_ingredients: int
 |
 |  class ApplePie(Pie):
 |      fruit: Literal['apple'] = 'apple'
 |
 |  class PumpkinPie(Pie):
 |      filling: Literal['pumpkin'] = 'pumpkin'
 |
 |  def get_discriminator_value(v: Any) -> str:
 |      if isinstance(v, dict):
 |          return v.get('fruit', v.get('filling'))
 |      return getattr(v, 'fruit', getattr(v, 'filling', None))
 |
 |  class ThanksgivingDinner(BaseModel):
 |      dessert: Annotated[
 |          Union[
 |              Annotated[ApplePie, Tag('apple')],
 |              Annotated[PumpkinPie, Tag('pumpkin')],
 |          ],
 |          Discriminator(get_discriminator_value),
 |      ]
 |
 |  apple_variation = ThanksgivingDinner.model_validate(
 |      {'dessert': {'fruit': 'apple', 'time_to_cook': 60, 'num_ingredients': 8}}
 |  )
 |  print(repr(apple_variation))
 |  '''
 |  ThanksgivingDinner(dessert=ApplePie(time_to_cook=60, num_ingredients=8, fruit='apple'))
 |  '''
 |
 |  pumpkin_variation = ThanksgivingDinner.model_validate(
 |      {
 |          'dessert': {
 |              'filling': 'pumpkin',
 |              'time_to_cook': 40,
 |              'num_ingredients': 6,
 |          }
 |      }
 |  )
 |  print(repr(pumpkin_variation))
 |  '''
 |  ThanksgivingDinner(dessert=PumpkinPie(time_to_cook=40, num_ingredients=6, filling='pumpkin'))
 |  '''
 |  ```
 |
 |  !!! note
 |      You must specify a `Tag` for every case in a `Tag` that is associated with a
 |      callable `Discriminator`. Failing to do so will result in a `PydanticUserError` with code
 |      [`callable-discriminator-no-tag`](../errors/usage_errors.md#callable-discriminator-no-tag).
 |
 |  See the [Discriminated Unions] concepts docs for more details on how to use `Tag`s.
 |
 |  [Discriminated Unions]: ../concepts/unions.md#discriminated-unions
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, tag: 'str') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  tag
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'tag': 'str'}
 |
 |  __dataclass_fields__ = {'tag': Field(name='tag',type='str',default=<da...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('tag',)

Python Library Documentation: class TypeAdapter in module pydantic.type_adapter

class TypeAdapter(typing.Generic)
 |  TypeAdapter(type: 'Any', *, config: 'ConfigDict | None' = None, _parent_depth: 'int' = 2, module: 'str | None' = None) -> 'None'
 |
 |  !!! abstract "Usage Documentation"
 |      [`TypeAdapter`](../concepts/type_adapter.md)
 |
 |  Type adapters provide a flexible way to perform validation and serialization based on a Python type.
 |
 |  A `TypeAdapter` instance exposes some of the functionality from `BaseModel` instance methods
 |  for types that do not have such methods (such as dataclasses, primitive types, and more).
 |
 |  **Note:** `TypeAdapter` instances are not types, and cannot be used as type annotations for fields.
 |
 |  Args:
 |      type: The type associated with the `TypeAdapter`.
 |      config: Configuration for the `TypeAdapter`, should be a dictionary conforming to
 |          [`ConfigDict`][pydantic.config.ConfigDict].
 |
 |          !!! note
 |              You cannot provide a configuration when instantiating a `TypeAdapter` if the type you're using
 |              has its own config that cannot be overridden (ex: `BaseModel`, `TypedDict`, and `dataclass`). A
 |              [`type-adapter-config-unused`](../errors/usage_errors.md#type-adapter-config-unused) error will
 |              be raised in this case.
 |      _parent_depth: Depth at which to search for the [parent frame][frame-objects]. This frame is used when
 |          resolving forward annotations during schema building, by looking for the globals and locals of this
 |          frame. Defaults to 2, which will result in the frame where the `TypeAdapter` was instantiated.
 |
 |          !!! note
 |              This parameter is named with an underscore to suggest its private nature and discourage use.
 |              It may be deprecated in a minor version, so we only recommend using it if you're comfortable
 |              with potential change in behavior/support. It's default value is 2 because internally,
 |              the `TypeAdapter` class makes another call to fetch the frame.
 |      module: The module that passes to plugin if provided.
 |
 |  Attributes:
 |      core_schema: The core schema for the type.
 |      validator: The schema validator for the type.
 |      serializer: The schema serializer for the type.
 |      pydantic_complete: Whether the core schema for the type is successfully built.
 |
 |  ??? tip "Compatibility with `mypy`"
 |      Depending on the type used, `mypy` might raise an error when instantiating a `TypeAdapter`. As a workaround, you can explicitly
 |      annotate your variable:
 |
 |      ```py
 |      from typing import Union
 |
 |      from pydantic import TypeAdapter
 |
 |      ta: TypeAdapter[Union[str, int]] = TypeAdapter(Union[str, int])  # type: ignore[arg-type]
 |      ```
 |
 |  ??? info "Namespace management nuances and implementation details"
 |
 |      Here, we collect some notes on namespace management, and subtle differences from `BaseModel`:
 |
 |      `BaseModel` uses its own `__module__` to find out where it was defined
 |      and then looks for symbols to resolve forward references in those globals.
 |      On the other hand, `TypeAdapter` can be initialized with arbitrary objects,
 |      which may not be types and thus do not have a `__module__` available.
 |      So instead we look at the globals in our parent stack frame.
 |
 |      It is expected that the `ns_resolver` passed to this function will have the correct
 |      namespace for the type we're adapting. See the source code for `TypeAdapter.__init__`
 |      and `TypeAdapter.rebuild` for various ways to construct this namespace.
 |
 |      This works for the case where this function is called in a module that
 |      has the target of forward references in its scope, but
 |      does not always work for more complex cases.
 |
 |      For example, take the following:
 |
 |      ```python {title="a.py"}
 |      IntList = list[int]
 |      OuterDict = dict[str, 'IntList']
 |      ```
 |
 |      ```python {test="skip" title="b.py"}
 |      from a import OuterDict
 |
 |      from pydantic import TypeAdapter
 |
 |      IntList = int  # replaces the symbol the forward reference is looking for
 |      v = TypeAdapter(OuterDict)
 |      v({'x': 1})  # should fail but doesn't
 |      ```
 |
 |      If `OuterDict` were a `BaseModel`, this would work because it would resolve
 |      the forward reference within the `a.py` namespace.
 |      But `TypeAdapter(OuterDict)` can't determine what module `OuterDict` came from.
 |
 |      In other words, the assumption that _all_ forward references exist in the
 |      module we are being called from is not technically always true.
 |      Although most of the time it is and it works fine for recursive models and such,
 |      `BaseModel`'s behavior isn't perfect either and _can_ break in similar ways,
 |      so there is no right or wrong between the two.
 |
 |      But at the very least this behavior is _subtly_ different from `BaseModel`'s.
 |
 |  Method resolution order:
 |      TypeAdapter
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, type: 'Any', *, config: 'ConfigDict | None' = None, _parent_depth: 'int' = 2, module: 'str | None' = None) -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  dump_json(self, instance: 'T', /, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None, context: 'Any | None' = None) -> 'bytes'
 |      !!! abstract "Usage Documentation"
 |          [JSON Serialization](../concepts/json.md#json-serialization)
 |
 |      Serialize an instance of the adapted type to JSON.
 |
 |      Args:
 |          instance: The instance to be serialized.
 |          indent: Number of spaces for JSON indentation.
 |          ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
 |              If `False` (the default), these characters will be output as-is.
 |          include: Fields to include.
 |          exclude: Fields to exclude.
 |          by_alias: Whether to use alias names for field names.
 |          exclude_unset: Whether to exclude unset fields.
 |          exclude_defaults: Whether to exclude fields with default values.
 |          exclude_none: Whether to exclude fields with a value of `None`.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: Whether to serialize and deserialize the instance to ensure round-tripping.
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |          context: Additional context to pass to the serializer.
 |
 |      Returns:
 |          The JSON representation of the given instance as bytes.
 |
 |  dump_python(self, instance: 'T', /, *, mode: "Literal['json', 'python']" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None, context: 'Any | None' = None) -> 'Any'
 |      Dump an instance of the adapted type to a Python object.
 |
 |      Args:
 |          instance: The Python object to serialize.
 |          mode: The output format.
 |          include: Fields to include in the output.
 |          exclude: Fields to exclude from the output.
 |          by_alias: Whether to use alias names for field names.
 |          exclude_unset: Whether to exclude unset fields.
 |          exclude_defaults: Whether to exclude fields with default values.
 |          exclude_none: Whether to exclude fields with None values.
 |          exclude_computed_fields: Whether to exclude computed fields.
 |              While this can be useful for round-tripping, it is usually recommended to use the dedicated
 |              `round_trip` parameter instead.
 |          round_trip: Whether to output the serialized data in a way that is compatible with deserialization.
 |          warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
 |              "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
 |          fallback: A function to call when an unknown value is encountered. If not provided,
 |              a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
 |          serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 |          polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
 |          context: Additional context to pass to the serializer.
 |
 |      Returns:
 |          The serialized object.
 |
 |  get_default_value(self, *, strict: 'bool | None' = None, context: 'Any | None' = None) -> 'Some[T] | None'
 |      Get the default value for the wrapped type.
 |
 |      Args:
 |          strict: Whether to strictly check types.
 |          context: Additional context to pass to the validator.
 |
 |      Returns:
 |          The default value wrapped in a `Some` if there is one or None if not.
 |
 |  json_schema(self, *, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation') -> 'dict[str, Any]'
 |      Generate a JSON schema for the adapted type.
 |
 |      Args:
 |          by_alias: Whether to use alias names for field names.
 |          ref_template: The format string used for generating $ref strings.
 |          union_format: The format to use when combining schemas from unions together. Can be one of:
 |
 |              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
 |              keyword to combine schemas (the default).
 |              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
 |              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
 |              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
 |              `any_of`.
 |          schema_generator: To override the logic used to generate the JSON schema, as a subclass of
 |              `GenerateJsonSchema` with your desired modifications
 |          mode: The mode in which to generate the schema.
 |          schema_generator: The generator class used for creating the schema.
 |          mode: The mode to use for schema generation.
 |
 |      Returns:
 |          The JSON schema for the model as a dictionary.
 |
 |  rebuild(self, *, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: '_namespace_utils.MappingNamespace | None' = None) -> 'bool | None'
 |      Try to rebuild the pydantic-core schema for the adapter's type.
 |
 |      This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
 |      the initial attempt to build the schema, and automatic rebuilding fails.
 |
 |      Args:
 |          force: Whether to force the rebuilding of the type adapter's schema, defaults to `False`.
 |          raise_errors: Whether to raise errors, defaults to `True`.
 |          _parent_namespace_depth: Depth at which to search for the [parent frame][frame-objects]. This
 |              frame is used when resolving forward annotations during schema rebuilding, by looking for
 |              the locals of this frame. Defaults to 2, which will result in the frame where the method
 |              was called.
 |          _types_namespace: An explicit types namespace to use, instead of using the local namespace
 |              from the parent frame. Defaults to `None`.
 |
 |      Returns:
 |          Returns `None` if the schema is already "complete" and rebuilding was not required.
 |          If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
 |
 |  validate_json(self, data: 'str | bytes | bytearray', /, *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, experimental_allow_partial: "bool | Literal['off', 'on', 'trailing-strings']" = False, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'T'
 |      !!! abstract "Usage Documentation"
 |          [JSON Parsing](../concepts/json.md#json-parsing)
 |
 |      Validate a JSON string or bytes against the model.
 |
 |      Args:
 |          data: The JSON data to validate against the model.
 |          strict: Whether to strictly check types.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Additional context to use during validation.
 |          experimental_allow_partial: **Experimental** whether to enable
 |              [partial validation](../concepts/experimental.md#partial-validation), e.g. to process streams.
 |              * False / 'off': Default behavior, no partial validation.
 |              * True / 'on': Enable partial validation.
 |              * 'trailing-strings': Enable partial validation and allow trailing strings in the input.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated object.
 |
 |  validate_python(self, object: 'Any', /, *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, experimental_allow_partial: "bool | Literal['off', 'on', 'trailing-strings']" = False, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'T'
 |      Validate a Python object against the model.
 |
 |      Args:
 |          object: The Python object to validate against the model.
 |          strict: Whether to strictly check types.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          from_attributes: Whether to extract data from object attributes.
 |          context: Additional context to pass to the validator.
 |          experimental_allow_partial: **Experimental** whether to enable
 |              [partial validation](../concepts/experimental.md#partial-validation), e.g. to process streams.
 |              * False / 'off': Default behavior, no partial validation.
 |              * True / 'on': Enable partial validation.
 |              * 'trailing-strings': Enable partial validation and allow trailing strings in the input.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      !!! note
 |          When using `TypeAdapter` with a Pydantic `dataclass`, the use of the `from_attributes`
 |          argument is not supported.
 |
 |      Returns:
 |          The validated object.
 |
 |  validate_strings(self, obj: 'Any', /, *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, experimental_allow_partial: "bool | Literal['off', 'on', 'trailing-strings']" = False, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'T'
 |      Validate object contains string data against the model.
 |
 |      Args:
 |          obj: The object contains string data to validate.
 |          strict: Whether to strictly check types.
 |          extra: Whether to ignore, allow, or forbid extra data during model validation.
 |              See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
 |          context: Additional context to use during validation.
 |          experimental_allow_partial: **Experimental** whether to enable
 |              [partial validation](../concepts/experimental.md#partial-validation), e.g. to process streams.
 |              * False / 'off': Default behavior, no partial validation.
 |              * True / 'on': Enable partial validation.
 |              * 'trailing-strings': Enable partial validation and allow trailing strings in the input.
 |          by_alias: Whether to use the field's alias when validating against the provided input data.
 |          by_name: Whether to use the field's name when validating against the provided input data.
 |
 |      Returns:
 |          The validated object.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  json_schemas(inputs: 'Iterable[tuple[JsonSchemaKeyT, JsonSchemaMode, TypeAdapter[Any]]]', /, *, by_alias: 'bool' = True, title: 'str | None' = None, description: 'str | None' = None, ref_template: 'str' = '#/$defs/{model}', union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>) -> 'tuple[dict[tuple[JsonSchemaKeyT, JsonSchemaMode], JsonSchemaValue], JsonSchemaValue]'
 |      Generate a JSON schema including definitions from multiple type adapters.
 |
 |      Args:
 |          inputs: Inputs to schema generation. The first two items will form the keys of the (first)
 |              output mapping; the type adapters will provide the core schemas that get converted into
 |              definitions in the output JSON schema.
 |          by_alias: Whether to use alias names.
 |          title: The title for the schema.
 |          description: The description for the schema.
 |          ref_template: The format string used for generating $ref strings.
 |          union_format: The format to use when combining schemas from unions together. Can be one of:
 |
 |              - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
 |              keyword to combine schemas (the default).
 |              - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
 |              keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
 |              type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
 |              `any_of`.
 |          schema_generator: The generator class used for creating the schema.
 |
 |      Returns:
 |          A tuple where:
 |
 |              - The first element is a dictionary whose keys are tuples of JSON schema key type and JSON mode, and
 |                  whose values are the JSON schema corresponding to that pair of inputs. (These schemas may have
 |                  JsonRef references to definitions that are defined in the second returned element.)
 |              - The second element is a JSON schema containing all definitions referenced in the first returned
 |                  element, along with the optional title and description keys.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'core_schema': 'CoreSchema', 'pydantic_complete': '...
 |
 |  __final__ = True
 |
 |  __orig_bases__ = (typing.Generic[~T],)
 |
 |  __parameters__ = (~T,)
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  __init_subclass__(...)
 |      Function to initialize subclasses.

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: _AnnotatedAlias in module typing

Annotated = class UUID(builtins.object)
 |  Annotated(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |
 |  Instances of the UUID class represent UUIDs as specified in RFC 4122.
 |  UUID objects are immutable, hashable, and usable as dictionary keys.
 |  Converting a UUID to a string with str() yields something in the form
 |  '12345678-1234-1234-1234-123456789abc'.  The UUID constructor accepts
 |  five possible forms: a similar string of hexadecimal digits, or a tuple
 |  of six integer fields (with 32-bit, 16-bit, 16-bit, 8-bit, 8-bit, and
 |  48-bit values respectively) as an argument named 'fields', or a string
 |  of 16 bytes (with all the integer fields in big-endian order) as an
 |  argument named 'bytes', or a string of 16 bytes (with the first three
 |  fields in little-endian order) as an argument named 'bytes_le', or a
 |  single 128-bit integer as an argument named 'int'.
 |
 |  UUIDs have these read-only attributes:
 |
 |      bytes       the UUID as a 16-byte string (containing the six
 |                  integer fields in big-endian byte order)
 |
 |      bytes_le    the UUID as a 16-byte string (with time_low, time_mid,
 |                  and time_hi_version in little-endian byte order)
 |
 |      fields      a tuple of the six integer fields of the UUID,
 |                  which are also available as six individual attributes
 |                  and two derived attributes:
 |
 |          time_low                the first 32 bits of the UUID
 |          time_mid                the next 16 bits of the UUID
 |          time_hi_version         the next 16 bits of the UUID
 |          clock_seq_hi_variant    the next 8 bits of the UUID
 |          clock_seq_low           the next 8 bits of the UUID
 |          node                    the last 48 bits of the UUID
 |
 |          time                    the 60-bit timestamp
 |          clock_seq               the 14-bit sequence number
 |
 |      hex         the UUID as a 32-character hexadecimal string
 |
 |      int         the UUID as a 128-bit integer
 |
 |      urn         the UUID as a URN as specified in RFC 4122
 |
 |      variant     the UUID variant (one of the constants RESERVED_NCS,
 |                  RFC_4122, RESERVED_MICROSOFT, or RESERVED_FUTURE)
 |
 |      version     the UUID version number (1 through 5, meaningful only
 |                  when the variant is RFC_4122)
 |
 |      is_safe     An enum indicating whether the UUID has been generated in
 |                  a way that is safe for multiprocessing applications, via
 |                  uuid_generate_time_safe(3).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __ge__(self, other)
 |      Return self>=value.
 |
 |  __getstate__(self)
 |      Helper for pickle.
 |
 |  __gt__(self, other)
 |      Return self>value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=<SafeUUID.unknown: None>)
 |      Create a UUID from either a string of 32 hexadecimal digits,
 |      a string of 16 bytes as the 'bytes' argument, a string of 16 bytes
 |      in little-endian order as the 'bytes_le' argument, a tuple of six
 |      integers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version,
 |      8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) as
 |      the 'fields' argument, or a single 128-bit integer as the 'int'
 |      argument.  When a string of hex digits is given, curly braces,
 |      hyphens, and a URN prefix are all optional.  For example, these
 |      expressions all yield the same UUID:
 |
 |      UUID('{12345678-1234-5678-1234-567812345678}')
 |      UUID('12345678123456781234567812345678')
 |      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
 |      UUID(bytes='\x12\x34\x56\x78'*4)
 |      UUID(bytes_le='\x78\x56\x34\x12\x34\x12\x78\x56' +
 |                    '\x12\x34\x56\x78\x12\x34\x56\x78')
 |      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
 |      UUID(int=0x12345678123456781234567812345678)
 |
 |      Exactly one of 'hex', 'bytes', 'bytes_le', 'fields', or 'int' must
 |      be given.  The 'version' argument is optional; if given, the resulting
 |      UUID will have its variant and version set according to RFC 4122,
 |      overriding the given 'hex', 'bytes', 'bytes_le', 'fields', or 'int'.
 |
 |      is_safe is an enum exposed as an attribute on the instance.  It
 |      indicates whether the UUID has been generated in a way that is safe
 |      for multiprocessing applications, via uuid_generate_time_safe(3).
 |
 |  __int__(self)
 |
 |  __le__(self, other)
 |      Return self<=value.
 |
 |  __lt__(self, other)
 |      Return self<value.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__(self, state)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  bytes
 |
 |  bytes_le
 |
 |  clock_seq
 |
 |  clock_seq_hi_variant
 |
 |  clock_seq_low
 |
 |  fields
 |
 |  hex
 |
 |  node
 |
 |  time
 |
 |  time_hi_version
 |
 |  time_low
 |
 |  time_mid
 |
 |  urn
 |
 |  variant
 |
 |  version
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  int
 |
 |  is_safe

Python Library Documentation: class UrlConstraints in module pydantic.networks

class UrlConstraints(builtins.object)
 |  UrlConstraints(max_length: 'int | None' = None, allowed_schemes: 'list[str] | None' = None, host_required: 'bool | None' = None, default_host: 'str | None' = None, default_port: 'int | None' = None, default_path: 'str | None' = None, preserve_empty_path: 'bool | None' = None) -> None
 |
 |  Url constraints.
 |
 |  Attributes:
 |      max_length: The maximum length of the url. Defaults to `None`.
 |      allowed_schemes: The allowed schemes. Defaults to `None`.
 |      host_required: Whether the host is required. Defaults to `None`.
 |      default_host: The default host. Defaults to `None`.
 |      default_port: The default port. Defaults to `None`.
 |      default_path: The default path. Defaults to `None`.
 |      preserve_empty_path: Whether to preserve empty URL paths. Defaults to `None`.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, max_length: 'int | None' = None, allowed_schemes: 'list[str] | None' = None, host_required: 'bool | None' = None, default_host: 'str | None' = None, default_port: 'int | None' = None, default_path: 'str | None' = None, preserve_empty_path: 'bool | None' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  defined_constraints
 |      Fetch a key / value mapping of constraints to values that are not None. Used for core schema updates.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'allowed_schemes': 'list[str] | None', 'default_hos...
 |
 |  __dataclass_fields__ = {'allowed_schemes': Field(name='allowed_schemes...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('max_length', 'allowed_schemes', 'host_required', 'd...
 |
 |  allowed_schemes = None
 |
 |  default_host = None
 |
 |  default_path = None
 |
 |  default_port = None
 |
 |  host_required = None
 |
 |  max_length = None
 |
 |  preserve_empty_path = None

Error rendering doc: No Python documentation found for '2.13.4'.
Use help() to get the interactive help utility.
Use help(str) for help on the str class.

Python Library Documentation: class ValidateAs in module pydantic.functional_validators

class ValidateAs(builtins.object)
 |  ValidateAs(from_type: 'type[_FromTypeT]', /, instantiation_hook: 'Callable[[_FromTypeT], Any]') -> 'None'
 |
 |  A helper class to validate a custom type from a type that is natively supported by Pydantic.
 |
 |  Args:
 |      from_type: The type natively supported by Pydantic to use to perform validation.
 |      instantiation_hook: A callable taking the validated type as an argument, and returning
 |          the populated custom type.
 |
 |  Example:
 |      ```python {lint="skip"}
 |      from typing import Annotated
 |
 |      from pydantic import BaseModel, TypeAdapter, ValidateAs
 |
 |      class MyCls:
 |          def __init__(self, a: int) -> None:
 |              self.a = a
 |
 |          def __repr__(self) -> str:
 |              return f"MyCls(a={self.a})"
 |
 |      class Model(BaseModel):
 |          a: int
 |
 |
 |      ta = TypeAdapter(
 |          Annotated[MyCls, ValidateAs(Model, lambda v: MyCls(a=v.a))]
 |      )
 |
 |      print(ta.validate_python({'a': 1}))
 |      #> MyCls(a=1)
 |      ```
 |
 |  Methods defined here:
 |
 |  __get_pydantic_core_schema__(self, source: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __init__(self, from_type: 'type[_FromTypeT]', /, instantiation_hook: 'Callable[[_FromTypeT], Any]') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class ValidationError in module pydantic_core._pydantic_core

class ValidationError(builtins.ValueError)
 |  ValidationError(title, line_errors, input_type='python', hide_input=False)
 |
 |  Method resolution order:
 |      ValidationError
 |      builtins.ValueError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __reduce__(self, /)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  error_count(self, /)
 |
 |  errors(self, /, *, include_url=True, include_context=True, include_input=True)
 |
 |  json(self, /, *, indent=None, include_url=True, include_context=True, include_input=True)
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_exception_data(title, line_errors, input_type='python', hide_input=False)
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  title
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.ValueError:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __setstate__(...)
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ValidationInfo in module pydantic_core.core_schema

class ValidationInfo(typing.Protocol)
 |  ValidationInfo(*args, **kwargs)
 |
 |  Extra data used during validation.
 |
 |  Method resolution order:
 |      ValidationInfo
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  config
 |      The CoreConfig that applies to this validation.
 |
 |  context
 |      The current validation context.
 |
 |  data
 |      The data being validated for this model.
 |
 |  field_name
 |      The name of the current field being validated if this validator is
 |      attached to a model field.
 |
 |  mode
 |      The type of input data we are currently validating.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __orig_bases__ = (typing.Protocol[+ContextT],)
 |
 |  __parameters__ = (+ContextT,)
 |
 |  __protocol_attrs__ = {'config', 'context', 'data', 'field_name', 'mode...
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class ValidatorFunctionWrapHandler in module pydantic_core.core_schema

class ValidatorFunctionWrapHandler(typing.Protocol)
 |  ValidatorFunctionWrapHandler(*args, **kwargs)
 |
 |  Method resolution order:
 |      ValidatorFunctionWrapHandler
 |      typing.Protocol
 |      typing.Generic
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __call__(self, input_value: 'Any', outer_location: 'str | int | None' = None, /) -> 'Any'
 |      Call self as a function.
 |
 |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {}
 |
 |  __parameters__ = ()
 |
 |  __protocol_attrs__ = {'__call__'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      Function to initialize subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.

Python Library Documentation: class WebsocketUrl in module pydantic.networks

class WebsocketUrl(AnyUrl)
 |  WebsocketUrl(url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |
 |  A type that will accept any ws or wss URL.
 |
 |  * TLD not required
 |  * Host not required
 |  * Max length 2083
 |
 |  Method resolution order:
 |      WebsocketUrl
 |      AnyUrl
 |      _BaseUrl
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from _BaseUrl:
 |
 |  __deepcopy__(self, memo: 'dict') -> 'Self'
 |
 |  __eq__(self, other: 'Any') -> 'bool'
 |      Return self==value.
 |
 |  __ge__(self, other: 'Any') -> 'bool'
 |      Return self>=value.
 |
 |  __gt__(self, other: 'Any') -> 'bool'
 |      Return self>value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, url: 'str | _CoreUrl | _BaseUrl') -> 'None'
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __le__(self, other: 'Any') -> 'bool'
 |      Return self<=value.
 |
 |  __len__(self) -> 'int'
 |
 |  __lt__(self, other: 'Any') -> 'bool'
 |      Return self<value.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      The URL as a string, this will punycode encode the host if required.
 |
 |  encoded_string(self) -> 'str'
 |      The URL's encoded string representation via __str__().
 |
 |      This returns the punycode-encoded host version of the URL as a string.
 |
 |  query_params(self) -> 'list[tuple[str, str]]'
 |      The query part of the URL as a list of key-value pairs.
 |
 |      e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
 |
 |  unicode_host(self) -> 'str | None'
 |      The host part of the URL as a unicode string, or `None`.
 |
 |      e.g. `host` in `https://user:pass@host:port/path?query#fragment`
 |
 |      If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
 |      `unicode_host()` will be `£££.com`
 |
 |  unicode_string(self) -> 'str'
 |      The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
 |
 |      If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
 |      `unicode_string()` will be `https://£££.com`
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from _BaseUrl:
 |
 |  __get_pydantic_core_schema__(source: 'type[_BaseUrl]', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __get_pydantic_json_schema__(core_schema: 'core_schema.CoreSchema', handler: '_schema_generation_shared.GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  build(*, scheme: 'str', username: 'str | None' = None, password: 'str | None' = None, host: 'str', port: 'int | None' = None, path: 'str | None' = None, query: 'str | None' = None, fragment: 'str | None' = None) -> 'Self'
 |      Build a new `Url` instance from its component parts.
 |
 |      Args:
 |          scheme: The scheme part of the URL.
 |          username: The username part of the URL, or omit for no username.
 |          password: The password part of the URL, or omit for no password.
 |          host: The host part of the URL.
 |          port: The port part of the URL, or omit for no port.
 |          path: The path part of the URL, or omit for no path.
 |          query: The query part of the URL, or omit for no query.
 |          fragment: The fragment part of the URL, or omit for no fragment.
 |
 |      Returns:
 |          An instance of URL
 |
 |  serialize_url(url: 'Any', info: 'core_schema.SerializationInfo') -> 'str | Self'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from _BaseUrl:
 |
 |  fragment
 |      The fragment part of the URL, or `None`.
 |
 |      e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
 |
 |  host
 |      The host part of the URL, or `None`.
 |
 |      If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
 |      `host` will be `xn--9aaa.com`
 |
 |  password
 |      The password part of the URL, or `None`.
 |
 |      e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
 |
 |  path
 |      The path part of the URL, or `None`.
 |
 |      e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
 |
 |  port
 |      The port part of the URL, or `None`.
 |
 |      e.g. `port` in `https://user:pass@host:port/path?query#fragment`
 |
 |  query
 |      The query part of the URL, or `None`.
 |
 |      e.g. `query` in `https://user:pass@host:port/path?query#fragment`
 |
 |  scheme
 |      The scheme part of the URL.
 |
 |      e.g. `https` in `https://user:pass@host:port/path?query#fragment`
 |
 |  username
 |      The username part of the URL, or `None`.
 |
 |      e.g. `user` in `https://user:pass@host:port/path?query#fragment`
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from _BaseUrl:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from _BaseUrl:
 |
 |  __pydantic_serializer__ = SchemaSerializer(serializer=ToString(
 |      To...

Python Library Documentation: class WithJsonSchema in module pydantic.json_schema

class WithJsonSchema(builtins.object)
 |  WithJsonSchema(json_schema: 'JsonSchemaValue | None', mode: "Literal['validation', 'serialization'] | None" = None) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [`WithJsonSchema` Annotation](../concepts/json_schema.md#withjsonschema-annotation)
 |
 |  An annotation used to override the JSON Schema for a type.
 |
 |  This is useful when you want to set a JSON Schema for a type that don't produce any JSON Schemas by default
 |  (e.g. [`Callable`][collections.abc.Callable]).
 |
 |  If `mode` is set this will only apply to that schema generation mode, allowing you to set different JSON Schemas for validation and serialization.
 |
 |  !!! note
 |      If the `WithJsonSchema` annotation is coupled with the [`Field()`][pydantic.Field] function, the behavior overriding will vary depending on the location:
 |
 |      * If the [`Annotated`][typing.Annotated] metadata is specified at the "top-level" field, `Field()` metadata arguments
 |        (excluding [constraints](../concepts/fields.md#field-constraints)) such as `title` and `description` will be applied on
 |        top of the `WithJsonSchema`, no matter the order:
 |
 |          ```python
 |          from typing import Annotated
 |
 |          from pydantic import BaseModel, Field, WithJsonSchema
 |
 |          class Model(BaseModel):
 |              field: Annotated[
 |                  int,
 |                  Field(title='My Field'),
 |                  WithJsonSchema({'type': 'integer', 'extra': 'data'}),
 |              ]
 |
 |          Model.model_json_schema()['properties']['field']
 |          #> {'type': 'integer', 'extra': 'data', 'title': 'My Field'}
 |          ```
 |
 |      * If the [`Annotated`][typing.Annotated] metadata is specified on a specific inner type, `WithJsonSchema` will unconditionally
 |        override the JSON Schema:
 |
 |          ```python
 |          from typing import Annotated
 |
 |          from pydantic import BaseModel, Field, WithJsonSchema
 |
 |          class Model(BaseModel):
 |              field: list[
 |                  Annotated[
 |                      int,
 |                      Field(title='My Field'),
 |                      WithJsonSchema({'type': 'integer', 'extra': 'data'}),
 |                  ]
 |              ]
 |
 |          Model.model_json_schema()['properties']['field']
 |          #> {'items': {'extra': 'data', 'type': 'integer'}, 'title': 'Field', 'type': 'array'}
 |          ```
 |
 |      See also the documentation about [the annotated pattern](../concepts/fields.md#the-annotated-pattern).
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_json_schema__(self, core_schema: 'core_schema.CoreSchema', handler: 'GetJsonSchemaHandler') -> 'JsonSchemaValue'
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, json_schema: 'JsonSchemaValue | None', mode: "Literal['validation', 'serialization'] | None" = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  json_schema
 |
 |  mode
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'json_schema': 'JsonSchemaValue | None', 'mode': "L...
 |
 |  __dataclass_fields__ = {'json_schema': Field(name='json_schema',type='...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('json_schema', 'mode')

Python Library Documentation: class WrapSerializer in module pydantic.functional_serializers

class WrapSerializer(builtins.object)
 |  WrapSerializer(func: 'core_schema.WrapSerializerFunction', return_type: 'Any' = PydanticUndefined, when_used: 'WhenUsed' = 'always') -> None
 |
 |  Wrap serializers receive the raw inputs along with a handler function that applies the standard serialization
 |  logic, and can modify the resulting value before returning it as the final output of serialization.
 |
 |  For example, here's a scenario in which a wrap serializer transforms timezones to UTC **and** utilizes the existing `datetime` serialization logic.
 |
 |  ```python
 |  from datetime import datetime, timezone
 |  from typing import Annotated, Any
 |
 |  from pydantic import BaseModel, WrapSerializer
 |
 |  class EventDatetime(BaseModel):
 |      start: datetime
 |      end: datetime
 |
 |  def convert_to_utc(value: Any, handler, info) -> dict[str, datetime]:
 |      # Note that `handler` can actually help serialize the `value` for
 |      # further custom serialization in case it's a subclass.
 |      partial_result = handler(value, info)
 |      if info.mode == 'json':
 |          return {
 |              k: datetime.fromisoformat(v).astimezone(timezone.utc)
 |              for k, v in partial_result.items()
 |          }
 |      return {k: v.astimezone(timezone.utc) for k, v in partial_result.items()}
 |
 |  UTCEventDatetime = Annotated[EventDatetime, WrapSerializer(convert_to_utc)]
 |
 |  class EventModel(BaseModel):
 |      event_datetime: UTCEventDatetime
 |
 |  dt = EventDatetime(
 |      start='2024-01-01T07:00:00-08:00', end='2024-01-03T20:00:00+06:00'
 |  )
 |  event = EventModel(event_datetime=dt)
 |  print(event.model_dump())
 |  '''
 |  {
 |      'event_datetime': {
 |          'start': datetime.datetime(
 |              2024, 1, 1, 15, 0, tzinfo=datetime.timezone.utc
 |          ),
 |          'end': datetime.datetime(
 |              2024, 1, 3, 14, 0, tzinfo=datetime.timezone.utc
 |          ),
 |      }
 |  }
 |  '''
 |
 |  print(event.model_dump_json())
 |  '''
 |  {"event_datetime":{"start":"2024-01-01T15:00:00Z","end":"2024-01-03T14:00:00Z"}}
 |  '''
 |  ```
 |
 |  Attributes:
 |      func: The serializer function to be wrapped.
 |      return_type: The return type for the function. If omitted it will be inferred from the type annotation.
 |      when_used: Determines when this serializer should be used. Accepts a string with values `'always'`,
 |          `'unless-none'`, `'json'`, and `'json-unless-none'`. Defaults to 'always'.
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |      This method is used to get the Pydantic core schema of the class.
 |
 |      Args:
 |          source_type: Source type.
 |          handler: Core schema handler.
 |
 |      Returns:
 |          The generated core schema of the class.
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.WrapSerializerFunction', return_type: 'Any' = PydanticUndefined, when_used: 'WhenUsed' = 'always') -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  return_type
 |
 |  when_used
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.WrapSerializerFunction', 'retu...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.Wr...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func', 'return_type', 'when_used')

Python Library Documentation: class WrapValidator in module pydantic.functional_validators

class WrapValidator(builtins.object)
 |  WrapValidator(func: 'core_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunction', json_schema_input_type: 'Any' = PydanticUndefined) -> None
 |
 |  !!! abstract "Usage Documentation"
 |      [field *wrap* validators](../concepts/validators.md#field-wrap-validator)
 |
 |  A metadata class that indicates that a validation should be applied **around** the inner validation logic.
 |
 |  Attributes:
 |      func: The validator function.
 |      json_schema_input_type: The input type used to generate the appropriate
 |          JSON Schema (in validation mode). The actual input type is `Any`.
 |
 |  ```python
 |  from datetime import datetime
 |  from typing import Annotated
 |
 |  from pydantic import BaseModel, ValidationError, WrapValidator
 |
 |  def validate_timestamp(v, handler):
 |      if v == 'now':
 |          # we don't want to bother with further validation, just return the new value
 |          return datetime.now()
 |      try:
 |          return handler(v)
 |      except ValidationError:
 |          # validation failed, in this case we want to return a default value
 |          return datetime(2000, 1, 1)
 |
 |  MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)]
 |
 |  class Model(BaseModel):
 |      a: MyTimestamp
 |
 |  print(Model(a='now').a)
 |  #> 2032-01-02 03:04:05.000006
 |  print(Model(a='invalid').a)
 |  #> 2000-01-01 00:00:00
 |  ```
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __get_pydantic_core_schema__(self, source_type: 'Any', handler: 'GetCoreSchemaHandler') -> 'core_schema.CoreSchema'
 |
 |  __getstate__ = _dataclass_getstate(self) from dataclasses
 |      # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
 |      # classes with slots.  These could be slightly more performant if we generated
 |      # the code instead of iterating over fields.  But that can be a project for
 |      # another day, if performance becomes an issue.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, func: 'core_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunction', json_schema_input_type: 'Any' = PydanticUndefined) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  __setstate__ = _dataclass_setstate(self, state) from dataclasses
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  func
 |
 |  json_schema_input_type
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'func': 'core_schema.NoInfoWrapValidatorFunction | ...
 |
 |  __dataclass_fields__ = {'func': Field(name='func',type='core_schema.No...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('func', 'json_schema_input_type')

Python Library Documentation: function computed_field in module pydantic.fields

computed_field(func: 'PropertyT | None' = None, /, *, alias: 'str | None' = None, alias_priority: 'int | None' = None, exclude_if: 'Callable[[Any], bool] | None' = None, title: 'str | None' = None, field_title_generator: 'Callable[[str, ComputedFieldInfo], str] | None' = None, description: 'str | None' = None, deprecated: 'Deprecated | str | bool | None' = None, examples: 'list[Any] | None' = None, json_schema_extra: 'JsonDict | Callable[[JsonDict], None] | None' = None, repr: 'bool | None' = None, return_type: 'Any' = PydanticUndefined) -> 'PropertyT | Callable[[PropertyT], PropertyT]'
    !!! abstract "Usage Documentation"
        [The `computed_field` decorator](../concepts/fields.md#the-computed_field-decorator)

    Decorator to include `property` and `cached_property` when serializing models or dataclasses.

    This is useful for fields that are computed from other fields, or for fields that are expensive to compute and should be cached.

    ```python
    from pydantic import BaseModel, computed_field

    class Rectangle(BaseModel):
        width: int
        length: int

        @computed_field
        @property
        def area(self) -> int:
            return self.width * self.length

    print(Rectangle(width=3, length=2).model_dump())
    #> {'width': 3, 'length': 2, 'area': 6}
    ```

    If applied to functions not yet decorated with `@property` or `@cached_property`, the function is
    automatically wrapped with `property`. Although this is more concise, you will lose IntelliSense in your IDE,
    and confuse static type checkers, thus explicit use of `@property` is recommended.

    !!! warning "Mypy Warning"
        Even with the `@property` or `@cached_property` applied to your function before `@computed_field`,
        mypy may throw a `Decorated property not supported` error.
        See [mypy issue #1362](https://github.com/python/mypy/issues/1362), for more information.
        To avoid this error message, add `# type: ignore[prop-decorator]` to the `@computed_field` line.

        [pyright](https://github.com/microsoft/pyright) supports `@computed_field` without error.

    ```python
    import random

    from pydantic import BaseModel, computed_field

    class Square(BaseModel):
        width: float

        @computed_field
        def area(self) -> float:  # converted to a `property` by `computed_field`
            return round(self.width**2, 2)

        @area.setter
        def area(self, new_area: float) -> None:
            self.width = new_area**0.5

        @computed_field(alias='the magic number', repr=False)
        def random_number(self) -> int:
            return random.randint(0, 1_000)

    square = Square(width=1.3)

    # `random_number` does not appear in representation
    print(repr(square))
    #> Square(width=1.3, area=1.69)

    print(square.random_number)
    #> 3

    square.area = 4

    print(square.model_dump_json(by_alias=True))
    #> {"width":2.0,"area":4.0,"the magic number":3}
    ```

    !!! warning "Overriding with `computed_field`"
        You can't override a field from a parent class with a `computed_field` in the child class.
        `mypy` complains about this behavior if allowed, and `dataclasses` doesn't allow this pattern either.
        See the example below:

    ```python
    from pydantic import BaseModel, computed_field

    class Parent(BaseModel):
        a: str

    try:

        class Child(Parent):
            @computed_field
            @property
            def a(self) -> str:
                return 'new a'

    except TypeError as e:
        print(e)
        '''
        Field 'a' of class 'Child' overrides symbol of same name in a parent class. This override with a computed_field is incompatible.
        '''
    ```

    Private properties decorated with `@computed_field` have `repr=False` by default.

    ```python
    from functools import cached_property

    from pydantic import BaseModel, computed_field

    class Model(BaseModel):
        foo: int

        @computed_field
        @cached_property
        def _private_cached_property(self) -> int:
            return -self.foo

        @computed_field
        @property
        def _private_property(self) -> int:
            return -self.foo

    m = Model(foo=1)
    print(repr(m))
    #> Model(foo=1)
    ```

    Args:
        func: the function to wrap.
        alias: alias to use when serializing this computed field, only used when `by_alias=True`
        alias_priority: priority of the alias. This affects whether an alias generator is used
        exclude_if: A callable that determines whether to exclude this computed field during serialization based on its value.
        title: Title to use when including this computed field in JSON Schema
        field_title_generator: A callable that takes a field name and returns title for it.
        description: Description to use when including this computed field in JSON Schema, defaults to the function's
            docstring
        deprecated: A deprecation message (or an instance of `warnings.deprecated` or the `typing_extensions.deprecated` backport).
            to be emitted when accessing the field. Or a boolean. This will automatically be set if the property is decorated with the
            `deprecated` decorator.
        examples: Example values to use when including this computed field in JSON Schema
        json_schema_extra: A dict or callable to provide extra JSON schema properties.
        repr: whether to include this computed field in model repr.
            Default is `False` for private properties and `True` for public properties.
        return_type: optional return for serialization logic to expect when serializing to JSON, if included
            this must be correct, otherwise a `TypeError` is raised.
            If you don't include a return type Any is used, which does runtime introspection to handle arbitrary
            objects.

    Returns:
        A proxy wrapper for the property.

Python Library Documentation: function conbytes in module pydantic.types

conbytes(*, min_length: 'int | None' = None, max_length: 'int | None' = None, strict: 'bool | None' = None) -> 'type[bytes]'
    A wrapper around `bytes` that allows for additional constraints.

    Args:
        min_length: The minimum length of the bytes.
        max_length: The maximum length of the bytes.
        strict: Whether to validate the bytes in strict mode.

    Returns:
        The wrapped bytes type.

Python Library Documentation: function condate in module pydantic.types

condate(*, strict: 'bool | None' = None, gt: 'date | None' = None, ge: 'date | None' = None, lt: 'date | None' = None, le: 'date | None' = None) -> 'type[date]'
    A wrapper for date that adds constraints.

    Args:
        strict: Whether to validate the date value in strict mode. Defaults to `None`.
        gt: The value must be greater than this. Defaults to `None`.
        ge: The value must be greater than or equal to this. Defaults to `None`.
        lt: The value must be less than this. Defaults to `None`.
        le: The value must be less than or equal to this. Defaults to `None`.

    Returns:
        A date type with the specified constraints.

Python Library Documentation: function condecimal in module pydantic.types

condecimal(*, strict: 'bool | None' = None, gt: 'int | Decimal | None' = None, ge: 'int | Decimal | None' = None, lt: 'int | Decimal | None' = None, le: 'int | Decimal | None' = None, multiple_of: 'int | Decimal | None' = None, max_digits: 'int | None' = None, decimal_places: 'int | None' = None, allow_inf_nan: 'bool | None' = None) -> 'type[Decimal]'
    !!! warning "Discouraged"
        This function is **discouraged** in favor of using
        [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated) with
        [`Field`][pydantic.fields.Field] instead.

        This function will be **deprecated** in Pydantic 3.0.

        The reason is that `condecimal` returns a type, which doesn't play well with static analysis tools.

        === ":x: Don't do this"
            ```python
            from pydantic import BaseModel, condecimal

            class Foo(BaseModel):
                bar: condecimal(strict=True, allow_inf_nan=True)
            ```

        === ":white_check_mark: Do this"
            ```python
            from decimal import Decimal
            from typing import Annotated

            from pydantic import BaseModel, Field

            class Foo(BaseModel):
                bar: Annotated[Decimal, Field(strict=True, allow_inf_nan=True)]
            ```

    A wrapper around Decimal that adds validation.

    Args:
        strict: Whether to validate the value in strict mode. Defaults to `None`.
        gt: The value must be greater than this. Defaults to `None`.
        ge: The value must be greater than or equal to this. Defaults to `None`.
        lt: The value must be less than this. Defaults to `None`.
        le: The value must be less than or equal to this. Defaults to `None`.
        multiple_of: The value must be a multiple of this. Defaults to `None`.
        max_digits: The maximum number of digits. Defaults to `None`.
        decimal_places: The number of decimal places. Defaults to `None`.
        allow_inf_nan: Whether to allow infinity and NaN. Defaults to `None`.

    ```python
    from decimal import Decimal

    from pydantic import BaseModel, ValidationError, condecimal

    class ConstrainedExample(BaseModel):
        constrained_decimal: condecimal(gt=Decimal('1.0'))

    m = ConstrainedExample(constrained_decimal=Decimal('1.1'))
    print(repr(m))
    #> ConstrainedExample(constrained_decimal=Decimal('1.1'))

    try:
        ConstrainedExample(constrained_decimal=Decimal('0.9'))
    except ValidationError as e:
        print(e.errors())
        '''
        [
            {
                'type': 'greater_than',
                'loc': ('constrained_decimal',),
                'msg': 'Input should be greater than 1.0',
                'input': Decimal('0.9'),
                'ctx': {'gt': Decimal('1.0')},
                'url': 'https://errors.pydantic.dev/2/v/greater_than',
            }
        ]
        '''
    ```

Python Library Documentation: function confloat in module pydantic.types

confloat(*, strict: 'bool | None' = None, gt: 'float | None' = None, ge: 'float | None' = None, lt: 'float | None' = None, le: 'float | None' = None, multiple_of: 'float | None' = None, allow_inf_nan: 'bool | None' = None) -> 'type[float]'
    !!! warning "Discouraged"
        This function is **discouraged** in favor of using
        [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated) with
        [`Field`][pydantic.fields.Field] instead.

        This function will be **deprecated** in Pydantic 3.0.

        The reason is that `confloat` returns a type, which doesn't play well with static analysis tools.

        === ":x: Don't do this"
            ```python
            from pydantic import BaseModel, confloat

            class Foo(BaseModel):
                bar: confloat(strict=True, gt=0)
            ```

        === ":white_check_mark: Do this"
            ```python
            from typing import Annotated

            from pydantic import BaseModel, Field

            class Foo(BaseModel):
                bar: Annotated[float, Field(strict=True, gt=0)]
            ```

    A wrapper around `float` that allows for additional constraints.

    Args:
        strict: Whether to validate the float in strict mode.
        gt: The value must be greater than this.
        ge: The value must be greater than or equal to this.
        lt: The value must be less than this.
        le: The value must be less than or equal to this.
        multiple_of: The value must be a multiple of this.
        allow_inf_nan: Whether to allow `-inf`, `inf`, and `nan`.

    Returns:
        The wrapped float type.

    ```python
    from pydantic import BaseModel, ValidationError, confloat

    class ConstrainedExample(BaseModel):
        constrained_float: confloat(gt=1.0)

    m = ConstrainedExample(constrained_float=1.1)
    print(repr(m))
    #> ConstrainedExample(constrained_float=1.1)

    try:
        ConstrainedExample(constrained_float=0.9)
    except ValidationError as e:
        print(e.errors())
        '''
        [
            {
                'type': 'greater_than',
                'loc': ('constrained_float',),
                'msg': 'Input should be greater than 1',
                'input': 0.9,
                'ctx': {'gt': 1.0},
                'url': 'https://errors.pydantic.dev/2/v/greater_than',
            }
        ]
        '''
    ```

Python Library Documentation: function confrozenset in module pydantic.types

confrozenset(item_type: 'type[HashableItemType]', *, min_length: 'int | None' = None, max_length: 'int | None' = None) -> 'type[frozenset[HashableItemType]]'
    A wrapper around `typing.FrozenSet` that allows for additional constraints.

    Args:
        item_type: The type of the items in the frozenset.
        min_length: The minimum length of the frozenset.
        max_length: The maximum length of the frozenset.

    Returns:
        The wrapped frozenset type.

Python Library Documentation: function conint in module pydantic.types

conint(*, strict: 'bool | None' = None, gt: 'int | None' = None, ge: 'int | None' = None, lt: 'int | None' = None, le: 'int | None' = None, multiple_of: 'int | None' = None) -> 'type[int]'
    !!! warning "Discouraged"
        This function is **discouraged** in favor of using
        [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated) with
        [`Field`][pydantic.fields.Field] instead.

        This function will be **deprecated** in Pydantic 3.0.

        The reason is that `conint` returns a type, which doesn't play well with static analysis tools.

        === ":x: Don't do this"
            ```python
            from pydantic import BaseModel, conint

            class Foo(BaseModel):
                bar: conint(strict=True, gt=0)
            ```

        === ":white_check_mark: Do this"
            ```python
            from typing import Annotated

            from pydantic import BaseModel, Field

            class Foo(BaseModel):
                bar: Annotated[int, Field(strict=True, gt=0)]
            ```

    A wrapper around `int` that allows for additional constraints.

    Args:
        strict: Whether to validate the integer in strict mode. Defaults to `None`.
        gt: The value must be greater than this.
        ge: The value must be greater than or equal to this.
        lt: The value must be less than this.
        le: The value must be less than or equal to this.
        multiple_of: The value must be a multiple of this.

    Returns:
        The wrapped integer type.

    ```python
    from pydantic import BaseModel, ValidationError, conint

    class ConstrainedExample(BaseModel):
        constrained_int: conint(gt=1)

    m = ConstrainedExample(constrained_int=2)
    print(repr(m))
    #> ConstrainedExample(constrained_int=2)

    try:
        ConstrainedExample(constrained_int=0)
    except ValidationError as e:
        print(e.errors())
        '''
        [
            {
                'type': 'greater_than',
                'loc': ('constrained_int',),
                'msg': 'Input should be greater than 1',
                'input': 0,
                'ctx': {'gt': 1},
                'url': 'https://errors.pydantic.dev/2/v/greater_than',
            }
        ]
        '''
    ```

Python Library Documentation: function conlist in module pydantic.types

conlist(item_type: 'type[AnyItemType]', *, min_length: 'int | None' = None, max_length: 'int | None' = None, unique_items: 'bool | None' = None) -> 'type[list[AnyItemType]]'
    A wrapper around [`list`][] that adds validation.

    Args:
        item_type: The type of the items in the list.
        min_length: The minimum length of the list. Defaults to None.
        max_length: The maximum length of the list. Defaults to None.
        unique_items: Whether the items in the list must be unique. Defaults to None.
            !!! warning Deprecated
                The `unique_items` parameter is deprecated, use `Set` instead.
                See [this issue](https://github.com/pydantic/pydantic-core/issues/296) for more details.

    Returns:
        The wrapped list type.

Python Library Documentation: function conset in module pydantic.types

conset(item_type: 'type[HashableItemType]', *, min_length: 'int | None' = None, max_length: 'int | None' = None) -> 'type[set[HashableItemType]]'
    A wrapper around `typing.Set` that allows for additional constraints.

    Args:
        item_type: The type of the items in the set.
        min_length: The minimum length of the set.
        max_length: The maximum length of the set.

    Returns:
        The wrapped set type.

Python Library Documentation: function constr in module pydantic.types

constr(*, strip_whitespace: 'bool | None' = None, to_upper: 'bool | None' = None, to_lower: 'bool | None' = None, strict: 'bool | None' = None, min_length: 'int | None' = None, max_length: 'int | None' = None, pattern: 'str | Pattern[str] | None' = None, ascii_only: 'bool | None' = None) -> 'type[str]'
    !!! warning "Discouraged"
        This function is **discouraged** in favor of using
        [`Annotated`](https://docs.python.org/3/library/typing.html#typing.Annotated) with
        [`StringConstraints`][pydantic.types.StringConstraints] instead.

        This function will be **deprecated** in Pydantic 3.0.

        The reason is that `constr` returns a type, which doesn't play well with static analysis tools.

        === ":x: Don't do this"
            ```python
            from pydantic import BaseModel, constr

            class Foo(BaseModel):
                bar: constr(strip_whitespace=True, to_upper=True, pattern=r'^[A-Z]+$')
            ```

        === ":white_check_mark: Do this"
            ```python
            from typing import Annotated

            from pydantic import BaseModel, StringConstraints

            class Foo(BaseModel):
                bar: Annotated[
                    str,
                    StringConstraints(
                        strip_whitespace=True, to_upper=True, pattern=r'^[A-Z]+$'
                    ),
                ]
            ```

    A wrapper around `str` that allows for additional constraints.

    ```python
    from pydantic import BaseModel, constr

    class Foo(BaseModel):
        bar: constr(strip_whitespace=True, to_upper=True)

    foo = Foo(bar='  hello  ')
    print(foo)
    #> bar='HELLO'
    ```

    Args:
        strip_whitespace: Whether to remove leading and trailing whitespace.
        to_upper: Whether to turn all characters to uppercase.
        to_lower: Whether to turn all characters to lowercase.
        strict: Whether to validate the string in strict mode.
        min_length: The minimum length of the string.
        max_length: The maximum length of the string.
        pattern: A regex pattern to validate the string against.
        ascii_only: Whether the string should contain only ASCII characters.

    Returns:
        The wrapped string type.

Python Library Documentation: function create_model in module pydantic.main

create_model(model_name: 'str', /, *, __config__: 'ConfigDict | None' = None, __doc__: 'str | None' = None, __base__: 'type[ModelT] | tuple[type[ModelT], ...] | None' = None, __module__: 'str | None' = None, __validators__: 'dict[str, Callable[..., Any]] | None' = None, __cls_kwargs__: 'dict[str, Any] | None' = None, __qualname__: 'str | None' = None, **field_definitions: 'Any | tuple[Any, Any]') -> 'type[ModelT]'
    !!! abstract "Usage Documentation"
        [Dynamic Model Creation](../concepts/models.md#dynamic-model-creation)

    Dynamically creates and returns a new Pydantic model, in other words, `create_model` dynamically creates a
    subclass of [`BaseModel`][pydantic.BaseModel].

    !!! warning
        This function may execute arbitrary code contained in field annotations, if string references need to be evaluated.

        See [Security implications of introspecting annotations](https://docs.python.org/3/library/annotationlib.html#annotationlib-security) for more information.

    Args:
        model_name: The name of the newly created model.
        __config__: The configuration of the new model.
        __doc__: The docstring of the new model.
        __base__: The base class or classes for the new model.
        __module__: The name of the module that the model belongs to;
            if `None`, the value is taken from `sys._getframe(1)`
        __validators__: A dictionary of methods that validate fields. The keys are the names of the validation methods to
            be added to the model, and the values are the validation methods themselves. You can read more about functional
            validators [here](https://docs.pydantic.dev/2.9/concepts/validators/#field-validators).
        __cls_kwargs__: A dictionary of keyword arguments for class creation, such as `metaclass`.
        __qualname__: The qualified name of the newly created model.
        **field_definitions: Field definitions of the new model. Either:

            - a single element, representing the type annotation of the field.
            - a two-tuple, the first element being the type and the second element the assigned value
              (either a default or the [`Field()`][pydantic.Field] function).

    Returns:
        The new [model][pydantic.BaseModel].

    Raises:
        PydanticUserError: If `__base__` and `__config__` are both passed.

Python Library Documentation: module pydantic.dataclasses in pydantic

NAME
    pydantic.dataclasses - Provide an enhanced dataclass that performs validation.

FUNCTIONS
    __getattr__ = wrapper(name: str) -> object
        Raise an error if the object is not found, or warn if it was moved.

        In case it was moved, it still returns the object.

        Args:
            name: The object name.

        Returns:
            The object.

    dataclass(_cls: 'type[_T] | None' = None, *, init: 'Literal[False]' = False, repr: 'bool' = True, eq: 'bool' = True, order: 'bool' = False, unsafe_hash: 'bool' = False, frozen: 'bool | None' = None, config: 'ConfigDict | type[object] | None' = None, validate_on_init: 'bool | None' = None, kw_only: 'bool' = False, slots: 'bool' = False) -> 'Callable[[type[_T]], type[PydanticDataclass]] | type[PydanticDataclass]'
        !!! abstract "Usage Documentation"
            [`dataclasses`](../concepts/dataclasses.md)

        A decorator used to create a Pydantic-enhanced dataclass, similar to the standard Python `dataclass`,
        but with added validation.

        This function should be used similarly to `dataclasses.dataclass`.

        Args:
            _cls: The target `dataclass`.
            init: Included for signature compatibility with `dataclasses.dataclass`, and is passed through to
                `dataclasses.dataclass` when appropriate. If specified, must be set to `False`, as pydantic inserts its
                own  `__init__` function.
            repr: A boolean indicating whether to include the field in the `__repr__` output.
            eq: Determines if a `__eq__` method should be generated for the class.
            order: Determines if comparison magic methods should be generated, such as `__lt__`, but not `__eq__`.
            unsafe_hash: Determines if a `__hash__` method should be included in the class, as in `dataclasses.dataclass`.
            frozen: Determines if the generated class should be a 'frozen' `dataclass`, which does not allow its
                attributes to be modified after it has been initialized. If not set, the value from the provided `config` argument will be used (and will default to `False` otherwise).
            config: The Pydantic config to use for the `dataclass`.
            validate_on_init: A deprecated parameter included for backwards compatibility; in V2, all Pydantic dataclasses
                are validated on init.
            kw_only: Determines if `__init__` method parameters must be specified by keyword only. Defaults to `False`.
            slots: Determines if the generated class should be a 'slots' `dataclass`, which does not allow the addition of
                new attributes after instantiation.

        Returns:
            A decorator that accepts a class as its argument and returns a Pydantic `dataclass`.

        Raises:
            AssertionError: Raised if `init` is not `False` or `validate_on_init` is `False`.

    rebuild_dataclass(cls: 'type[PydanticDataclass]', *, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
        Try to rebuild the pydantic-core schema for the dataclass.

        This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
        the initial attempt to build the schema, and automatic rebuilding fails.

        This is analogous to `BaseModel.model_rebuild`.

        Args:
            cls: The class to rebuild the pydantic-core schema for.
            force: Whether to force the rebuilding of the schema, defaults to `False`.
            raise_errors: Whether to raise errors, defaults to `True`.
            _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
            _types_namespace: The types namespace, defaults to `None`.

        Returns:
            Returns `None` if the schema is already "complete" and rebuilding was not required.
            If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.

DATA
    __all__ = ('dataclass', 'rebuild_dataclass')

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\pydantic\dataclasses.py

Python Library Documentation: function field_serializer in module pydantic.functional_serializers

field_serializer(field: 'str', /, *fields: 'str', mode: "Literal['plain', 'wrap']" = 'plain', return_type: 'Any' = PydanticUndefined, when_used: 'WhenUsed' = 'always', check_fields: 'bool | None' = None) -> 'Callable[[_FieldWrapSerializerT], _FieldWrapSerializerT] | Callable[[_FieldPlainSerializerT], _FieldPlainSerializerT]'
    Decorator that enables custom field serialization.

    In the below example, a field of type `set` is used to mitigate duplication. A `field_serializer` is used to serialize the data as a sorted list.

    ```python
    from pydantic import BaseModel, field_serializer

    class StudentModel(BaseModel):
        name: str = 'Jane'
        courses: set[str]

        @field_serializer('courses', when_used='json')
        def serialize_courses_in_order(self, courses: set[str]):
            return sorted(courses)

    student = StudentModel(courses={'Math', 'Chemistry', 'English'})
    print(student.model_dump_json())
    #> {"name":"Jane","courses":["Chemistry","English","Math"]}
    ```

    See [the usage documentation](../concepts/serialization.md#serializers) for more information.

    Four signatures are supported for the decorated serializer:

    - `(self, value: Any, info: FieldSerializationInfo)`
    - `(self, value: Any, nxt: SerializerFunctionWrapHandler, info: FieldSerializationInfo)`
    - `(value: Any, info: SerializationInfo)`
    - `(value: Any, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)`

    Args:
        *fields: The field names the serializer should apply to.
        mode: The serialization mode.

            - `plain` means the function will be called instead of the default serialization logic,
            - `wrap` means the function will be called with an argument to optionally call the
               default serialization logic.
        return_type: Optional return type for the function, if omitted it will be inferred from the type annotation.
        when_used: Determines the serializer will be used for serialization.
        check_fields: Whether to check that the fields actually exist on the model.

    Raises:
        PydanticUserError:
            - If the decorator is used without any arguments (at least one field name must be provided).
            - If the provided field names are not strings.

Python Library Documentation: function field_validator in module pydantic.functional_validators

field_validator(field: 'str', /, *fields: 'str', mode: 'FieldValidatorModes' = 'after', check_fields: 'bool | None' = None, json_schema_input_type: 'Any' = PydanticUndefined) -> 'Callable[[Any], Any]'
    !!! abstract "Usage Documentation"
        [field validators](../concepts/validators.md#field-validators)

    Decorate methods on the class indicating that they should be used to validate fields.

    Example usage:
    ```python
    from typing import Any

    from pydantic import (
        BaseModel,
        ValidationError,
        field_validator,
    )

    class Model(BaseModel):
        a: str

        @field_validator('a')
        @classmethod
        def ensure_foobar(cls, v: Any):
            if 'foobar' not in v:
                raise ValueError('"foobar" not found in a')
            return v

    print(repr(Model(a='this is foobar good')))
    #> Model(a='this is foobar good')

    try:
        Model(a='snap')
    except ValidationError as exc_info:
        print(exc_info)
        '''
        1 validation error for Model
        a
          Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str]
        '''
    ```

    For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators).

    Args:
        *fields: The field names the validator should apply to.
        mode: Specifies whether to validate the fields before or after validation.
        check_fields: Whether to check that the fields actually exist on the model.
        json_schema_input_type: The input type of the function. This is only used to generate
            the appropriate JSON Schema (in validation mode) and can only specified
            when `mode` is either `'before'`, `'plain'` or `'wrap'`.

    Raises:
        PydanticUserError:
            - If the decorator is used without any arguments (at least one field name must be provided).
            - If the provided field names are not strings.
            - If `json_schema_input_type` is provided with an unsupported `mode`.
            - If the decorator is applied to an instance method.

Python Library Documentation: function model_serializer in module pydantic.functional_serializers

model_serializer(f: '_ModelPlainSerializerT | _ModelWrapSerializerT | None' = None, /, *, mode: "Literal['plain', 'wrap']" = 'plain', when_used: 'WhenUsed' = 'always', return_type: 'Any' = PydanticUndefined) -> '_ModelPlainSerializerT | Callable[[_ModelWrapSerializerT], _ModelWrapSerializerT] | Callable[[_ModelPlainSerializerT], _ModelPlainSerializerT]'
    Decorator that enables custom model serialization.

    This is useful when a model need to be serialized in a customized manner, allowing for flexibility beyond just specific fields.

    An example would be to serialize temperature to the same temperature scale, such as degrees Celsius.

    ```python
    from typing import Literal

    from pydantic import BaseModel, model_serializer

    class TemperatureModel(BaseModel):
        unit: Literal['C', 'F']
        value: int

        @model_serializer()
        def serialize_model(self):
            if self.unit == 'F':
                return {'unit': 'C', 'value': int((self.value - 32) / 1.8)}
            return {'unit': self.unit, 'value': self.value}

    temperature = TemperatureModel(unit='F', value=212)
    print(temperature.model_dump())
    #> {'unit': 'C', 'value': 100}
    ```

    Two signatures are supported for `mode='plain'`, which is the default:

    - `(self)`
    - `(self, info: SerializationInfo)`

    And two other signatures for `mode='wrap'`:

    - `(self, nxt: SerializerFunctionWrapHandler)`
    - `(self, nxt: SerializerFunctionWrapHandler, info: SerializationInfo)`

        See [the usage documentation](../concepts/serialization.md#serializers) for more information.

    Args:
        f: The function to be decorated.
        mode: The serialization mode.

            - `'plain'` means the function will be called instead of the default serialization logic
            - `'wrap'` means the function will be called with an argument to optionally call the default
                serialization logic.
        when_used: Determines when this serializer should be used.
        return_type: The return type for the function. If omitted it will be inferred from the type annotation.

    Returns:
        The decorator function.

Python Library Documentation: function model_validator in module pydantic.functional_validators

model_validator(*, mode: "Literal['wrap', 'before', 'after']") -> 'Any'
    !!! abstract "Usage Documentation"
        [Model Validators](../concepts/validators.md#model-validators)

    Decorate model methods for validation purposes.

    Example usage:
    ```python
    from typing_extensions import Self

    from pydantic import BaseModel, ValidationError, model_validator

    class Square(BaseModel):
        width: float
        height: float

        @model_validator(mode='after')
        def verify_square(self) -> Self:
            if self.width != self.height:
                raise ValueError('width and height do not match')
            return self

    s = Square(width=1, height=1)
    print(repr(s))
    #> Square(width=1.0, height=1.0)

    try:
        Square(width=1, height=2)
    except ValidationError as e:
        print(e)
        '''
        1 validation error for Square
          Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict]
        '''
    ```

    For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators).

    Args:
        mode: A required string literal that specifies the validation mode.
            It can be one of the following: 'wrap', 'before', or 'after'.

    Returns:
        A decorator that can be used to decorate a function to be used as a model validator.

Python Library Documentation: function parse_obj_as in module pydantic.deprecated.tools

parse_obj_as(type_: 'type[T]', obj: 'Any', type_name: 'NameFactory | None' = None) -> 'T'

Python Library Documentation: function root_validator in module pydantic.deprecated.class_validators

root_validator(*__args, pre: 'bool' = False, skip_on_failure: 'bool' = False, allow_reuse: 'bool' = False) -> 'Any'
    Decorate methods on a model indicating that they should be used to validate (and perhaps
    modify) data either before or after standard model parsing/validation is performed.

    Args:
        pre (bool, optional): Whether this validator should be called before the standard
            validators (else after). Defaults to False.
        skip_on_failure (bool, optional): Whether to stop validation and return as soon as a
            failure is encountered. Defaults to False.
        allow_reuse (bool, optional): Whether to track and raise an error if another validator
            refers to the decorated function. Defaults to False.

    Returns:
        Any: A decorator that can be used to decorate a function to be used as a root_validator.

Python Library Documentation: function schema_json_of in module pydantic.deprecated.tools

schema_json_of(type_: 'Any', *, title: 'NameFactory | None' = None, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, **dumps_kwargs: 'Any') -> 'str'
    Generate a JSON schema (as JSON) for the passed model or dynamically generated one.

Python Library Documentation: function schema_of in module pydantic.deprecated.tools

schema_of(type_: 'Any', *, title: 'NameFactory | None' = None, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>) -> 'dict[str, Any]'
    Generate a JSON schema (as dict) for the passed model or dynamically generated one.

Python Library Documentation: function validate_call in module pydantic.validate_call_decorator

validate_call(func: 'AnyCallableT | None' = None, /, *, config: 'ConfigDict | None' = None, validate_return: 'bool' = False) -> 'AnyCallableT | Callable[[AnyCallableT], AnyCallableT]'
    !!! abstract "Usage Documentation"
        [Validation Decorator](../concepts/validation_decorator.md)

    Returns a decorated wrapper around the function that validates the arguments and, optionally, the return value.

    Usage may be either as a plain decorator `@validate_call` or with arguments `@validate_call(...)`.

    Args:
        func: The function to be decorated.
        config: The configuration dictionary.
        validate_return: Whether to validate the return value.

    Returns:
        The decorated function.

Python Library Documentation: function validate_email in module pydantic.networks

validate_email(value: 'str') -> 'tuple[str, str]'
    Email address validation using [email-validator](https://pypi.org/project/email-validator/).

    Returns:
        A tuple containing the local part of the email (or the name for "pretty" email addresses)
            and the normalized email.

    Raises:
        PydanticCustomError: If the email is invalid.

    Note:
        Note that:

        * Raw IP address (literal) domain parts are not allowed.
        * `"John Doe <local_part@domain.com>"` style "pretty" email addresses are processed.
        * Spaces are striped from the beginning and end of addresses, but no error is raised.

Python Library Documentation: function validator in module pydantic.deprecated.class_validators

validator(__field: 'str', *fields: 'str', pre: 'bool' = False, each_item: 'bool' = False, always: 'bool' = False, check_fields: 'bool | None' = None, allow_reuse: 'bool' = False) -> 'Callable[[_V1ValidatorType], _V1ValidatorType]'
    Decorate methods on the class indicating that they should be used to validate fields.

    Args:
        __field (str): The first field the validator should be called on; this is separate
            from `fields` to ensure an error is raised if you don't pass at least one.
        *fields (str): Additional field(s) the validator should be called on.
        pre (bool, optional): Whether this validator should be called before the standard
            validators (else after). Defaults to False.
        each_item (bool, optional): For complex objects (sets, lists etc.) whether to validate
            individual elements rather than the whole object. Defaults to False.
        always (bool, optional): Whether this method and other validators should be called even if
            the value is missing. Defaults to False.
        check_fields (bool | None, optional): Whether to check that the fields actually exist on the model.
            Defaults to None.
        allow_reuse (bool, optional): Whether to track and raise an error if another validator refers to
            the decorated function. Defaults to False.

    Returns:
        Callable: A decorator that can be used to decorate a
            function to be used as a validator.

Python Library Documentation: function with_config in module pydantic.config

with_config(config: 'ConfigDict | None' = None, /, **kwargs: 'Any') -> 'Callable[[_TypeT], _TypeT]'
    !!! abstract "Usage Documentation"
        [Configuration with other types](../concepts/config.md#configuration-on-other-supported-types)

    A convenience decorator to set a [Pydantic configuration](config.md) on a `TypedDict` or a `dataclass` from the standard library.

    Although the configuration can be set using the `__pydantic_config__` attribute, it does not play well with type checkers,
    especially with `TypedDict`.

    !!! example "Usage"

        ```python
        from typing_extensions import TypedDict

        from pydantic import ConfigDict, TypeAdapter, with_config

        @with_config(ConfigDict(str_to_lower=True))
        class TD(TypedDict):
            x: str

        ta = TypeAdapter(TD)

        print(ta.validate_python({'x': 'ABC'}))
        #> {'x': 'abc'}
        ```

    /// deprecated-removed | v2.11 v3
    Passing `config` as a keyword argument.
    ///

    /// version-changed | v2.11
    Keyword arguments can be provided directly instead of a config dictionary.
    ///