deb822 - pydoc - phpman

Help on module deb822:

NAME
    deb822 - Deprecated interface to `debian.deb822`

DATA
    Any = typing.Any
        Special type indicating an unconstrained type.

        - Any is compatible with every type.
        - Any assumed to have all methods.
        - All values assumed to be instances of Any.

        Note that all the above statements are true from the point of view of
        static type checkers. At runtime, Any should not be used with instance
        or class checks.

    Callable = typing.Callable
        Callable type; Callable[[int], str] is a function of (int) -> str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.  The argument list
        must be a list of types or ellipsis; the return type must be a single type.

        There is no syntax to indicate optional or keyword arguments,
        such function types are rarely used as callback types.

    Deb822Mapping = None
    Deb822MutableMapping = typing.MutableMapping[str, typing.Any]
    Deb822ValueType = typing.Any
        Special type indicating an unconstrained type.

        - Any is compatible with every type.
        - Any assumed to have all methods.
        - All values assumed to be instances of Any.

        Note that all the above statements are true from the point of view of
        static type checkers. At runtime, Any should not be used with instance
        or class checks.

    Dict = typing.Dict
        A generic version of dict.

    FrozenSet = typing.FrozenSet
        A generic version of frozenset.

    GPGV_DEFAULT_KEYRINGS = frozenset({'/usr/share/keyrings/debian-keyring...
    GPGV_EXECUTABLE = '/usr/bin/gpgv'
    Generator = typing.Generator
        A generic version of collections.abc.Generator.

    IO = {<class 'bytes'>: None, <class 'str'>: None}
    InputDataType = None
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    IterableInputDataType = typing.Union[typing.IO[str], typing.IO[bytes],...
    Iterator = typing.Iterator
        A generic version of collections.abc.Iterator.

    List = typing.List
        A generic version of list.

    Mapping = typing.Mapping
        A generic version of collections.abc.Mapping.

    MutableMapping = typing.MutableMapping
        A generic version of collections.abc.MutableMapping.

    Optional = typing.Optional
        Optional type.

        Optional[X] is equivalent to Union[X, None].

    Set = typing.Set
        A generic version of set.

    TYPE_CHECKING = False
    T_Deb822Dict = ~T_Deb822Dict
    Tuple = typing.Tuple
        Tuple type; Tuple[X, Y] is the cross-product type of X and Y.

        Example: Tuple[T1, T2] is a tuple of two elements corresponding
        to type variables T1 and T2.  Tuple[int, float, str] is a tuple
        of an int, a float and a string.

        To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].

    Type = typing.Type
        A special construct usable to annotate class objects.

        For example, suppose we have the following classes::

          class User: ...  # Abstract base for User classes
          class BasicUser(User): ...
          class ProUser(User): ...
          class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

          U = TypeVar('U', bound=User)
          def new_user(user_class: Type[U]) -> U:
              user = user_class()
              # (Here we could write the user object to a database)
              return user

          joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        To define a union, use e.g. Union[int, str].  Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    /usr/lib/python3/dist-packages/deb822.py