Python typing.Literal() Examples

def open_bytes(self, mode='rb'):
    # type: (Text) -> ContextManager[BinaryIO]
    """Return a context manager for opening the file in binary mode.

    Args:
      mode: The mode to open the file in. The "b" mode is implicit if not
        already present. It must not have the "t" flag.

    Returns:
      Context manager that yields an open file.

    Raises:
      ValueError: if invalid inputs are provided.
    """
    if 't' in mode:
      raise ValueError('Invalid mode {!r}: "t" flag not allowed when opening '
                       'file in binary mode'.format(mode))
    if 'b' not in mode:
      mode += 'b'
    cm = self._open(mode, encoding=None, errors=None)  # type: ContextManager[BinaryIO]
    return cm

  # TODO(b/123775699): Once pytype supports typing.Literal, use overload and
  # Literal to express more precise return types and remove the type comments in
  # open_text and open_bytes. 

def _ti_get_origin(tp):
        import typing_inspect as ti
        if type(tp) is type(Literal):  # Py<=3.6.
            return Literal
        origin = ti.get_origin(tp)
        return {  # Py<=3.6.
            typing.List: list,
            typing.Iterable: collections.abc.Iterable,
            typing.Sequence: collections.abc.Sequence,
            typing.Tuple: tuple,
        }.get(origin, origin) 

def test_is_instance_with_optional_literal_and_not_matching_type():
    from typing import Literal

    assert not is_instance("C", Optional[Literal["A", "B"]]) 

def test_from_dict_with_literal():
    from typing import Literal

    @dataclass
    class X:
        l: Literal["A", "B"]

    result = from_dict(X, {"l": "A"})

    assert result == X(l="A") 

def test_from_dict_with_literal_and_wrong_value():
    from typing import Literal

    @dataclass
    class X:
        l: Literal["A", "B"]

    with pytest.raises(WrongTypeError) as exception_info:
        from_dict(X, {"l": "C"}) 

def test_from_dict_with_optional_literal_and_none():
    from typing import Literal

    @dataclass
    class X:
        l: Optional[Literal["A", "B"]]

    result = from_dict(X, {"l": None})

    assert result == X(l=None) 

def test_from_dict_with_optional_literal_and_not_none():
    from typing import Literal

    @dataclass
    class X:
        l: Optional[Literal["A", "B"]]

    result = from_dict(X, {"l": "A"})

    assert result == X(l="A") 

def choose_literal(arg: Literal["foo", "bar"], *,
                   opt: Literal["baz", "quu"] = None):
    """
    Example function with `typing.Literal` arguments.

    :param arg: Choice to display
    :param opt: Optional choice to display
    """
    print(arg)
    if opt:
        print(opt) 

def _ti_get_args(tp):
        import typing_inspect as ti
        if type(tp) is type(Literal):  # Py<=3.6.
            return tp.__values__
        return ti.get_args(tp, evaluate=True)  # evaluate=True default on Py>=3.7. 

def test_is_instance_with_optional_literal_and_matching_type():
    from typing import Literal

    assert is_instance("A", Optional[Literal["A", "B"]]) 

def _get_parser(type_, parsers):
    try:
        parser = functools.partial(parsers[type_])
    except KeyError:
        if (type_ in [str, int, float]
                or isinstance(type_, type) and issubclass(type_, PurePath)):
            parser = functools.partial(type_)
        elif type_ == bool:
            parser = functools.partial(_parse_bool)
        elif type_ == slice:
            parser = functools.partial(_parse_slice)
        elif type_ == list:
            raise ValueError('unable to parse list (try list[type])')
        elif isinstance(type_, type) and issubclass(type_, Enum):
            parser = _make_enum_parser(type_)
        elif _is_constructible_from_str(type_):
            parser = functools.partial(type_)
        elif _ti_get_origin(type_) is Union:
            parser = _make_union_parser(
                type_,
                [_get_parser(arg, parsers) for arg in _ti_get_args(type_)])
        elif _ti_get_origin(type_) is Literal:  # Py>=3.7.
            parser = _make_literal_parser(
                type_,
                [_get_parser(type(arg), parsers)
                 for arg in _ti_get_args(type_)])
        else:
            raise Exception('no parser found for type {}'.format(
                # typing types have no __name__.
                getattr(type_, '__name__', repr(type_))))
    # Set the name that the user expects to see in error messages (we always
    # return a temporary partial object so it's safe to set its __name__).
    # Unions and Literals don't have a __name__, but their str is fine.
    parser.__name__ = getattr(type_, '__name__', str(type_))
    return parser 

def __instancecheck__(self, obj):
            raise TypeError("Literal cannot be used with isinstance().") 

def __subclasscheck__(self, cls):
            raise TypeError("Literal cannot be used with issubclass().") 

def __eq__(self, other):
            if not isinstance(other, Literal):
                return NotImplemented
            if self.__values__ is not None:
                return self.__values__ == other.__values__
            return self is other 

def is_literal_type(type_: Type[Any]) -> bool:
        return Literal is not None and getattr(type_, '__origin__', None) is Literal 

def is_literal_type(type_: Type[Any]) -> bool:
        return Literal is not None and hasattr(type_, '__values__') and type_ == Literal[type_.__values__] 

def all_literal_values(type_: Type[Any]) -> Tuple[Any, ...]:
    """
    This method is used to retrieve all Literal values as
    Literal can be used recursively (see https://www.python.org/dev/peps/pep-0586)
    e.g. `Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]`
    """
    if not is_literal_type(type_):
        return (type_,)

    values = literal_values(type_)
    return tuple(x for value in values for x in all_literal_values(value)) 

def request(
				self, path: str,
				args: ty.Sequence[str] = [], *,
				opts: ty.Mapping[str, str] = {},
				decoder: str = "none",
				stream: bool = False,
				offline: bool = False,
				return_result: ty.Literal[False],
				auth: auth_t = None,
				cookies: cookies_t = None,
				data: reqdata_sync_t = None,
				headers: headers_t = None,
				timeout: timeout_t = None
		) -> None:
			... 

def test_is_instance_with_literal_and_not_matching_type():
    from typing import Literal

    assert not is_instance("C", Literal["A", "B"]) 

def test_is_instance_with_literal_and_matching_type():
    from typing import Literal

    assert is_instance("A", Literal["A", "B"]) 

def test_is_literal_with_literal():
    from typing import Literal

    assert is_literal(Literal["A", "B"]) 

def __getitem__(cls, values):
                if not isinstance(values, tuple):
                    values = (values,)
                return type("Literal_", (Literal,), dict(__args__=values)) 

def test_literal_union_type_typing(self):
        self.flakes("""
        from typing import Literal

        def f(x: Literal['some string', 'foo bar']) -> None:
            return None
        """) 

def test_literal_type_some_other_module(self):
        """err on the side of false-negatives for types named Literal"""
        self.flakes("""
        from my_module import compat
        from my_module.compat import Literal

        def f(x: compat.Literal['some string']) -> None:
            return None
        def g(x: Literal['some string']) -> None:
            return None
        """) 

def test_literal_type_typing_extensions(self):
        self.flakes("""
        from typing_extensions import Literal

        def f(x: Literal['some string']) -> None:
            return None
        """) 

def test_literal_type_typing(self):
        self.flakes("""
        from typing import Literal

        def f(x: Literal['some string']) -> None:
            return None
        """) 

def read_tsv(
    path: Path, as_dict: Literal[True], columns: List[str], **kwargs
) -> Generator[Dict[str, str], None, None]:
    ... 

def read_tsv(
    path: Path, as_dict: Literal[False], **kwargs
) -> Generator[List[str], None, None]:
    ... 

def __getitem__(cls, values):
                if not isinstance(values, tuple):
                    values = (values,)
                return type('Literal_', (Literal,), dict(__args__=values)) 

def get_encoding(name: ty.Literal["none"]) -> Dummy:
		...