Lines Matching refs:Union
19 from typing import Union, Optional, Literal
415 self.assertEqual(Union[X], X)
416 self.assertNotEqual(Union[X], Union[X, Y])
417 self.assertEqual(Union[X, X], X)
418 self.assertNotEqual(Union[X, int], Union[X])
419 self.assertNotEqual(Union[X, int], Union[int])
420 self.assertEqual(Union[X, int].__args__, (X, int))
421 self.assertEqual(Union[X, int].__parameters__, (X,))
422 self.assertIs(Union[X, int].__origin__, Union)
428 self.assertEqual(X | "x", Union[X, "x"])
429 self.assertEqual("x" | X, Union["x", X])
436 self.assertNotEqual(Union[A, str], Union[A])
468 TypeVar('X', bound=Union)
494 self.assertEqual(subst(Union[int, str]), Union[int, str])
499 (), (int, str), Union,
1657 u = Union[int, float]
1658 self.assertNotEqual(u, Union)
1662 issubclass(int, Union)
1664 issubclass(Union, int)
1666 issubclass(Union[int, str], int)
1669 u = Union[Any]
1671 u1 = Union[int, Any]
1672 u2 = Union[Any, int]
1673 u3 = Union[Any, object]
1680 u = Union[object]
1682 u1 = Union[int, object]
1683 u2 = Union[object, int]
1689 u1 = Union[int, float]
1690 u2 = Union[float, int]
1694 t = Union[Employee]
1698 u = Union[Employee, Manager]
1704 u = Union[int, float]
1705 v = Union[u, Employee]
1706 self.assertEqual(v, Union[int, float, Employee])
1709 self.assertEqual(repr(Union), 'typing.Union')
1710 u = Union[Employee, int]
1711 self.assertEqual(repr(u), 'typing.Union[%s.Employee, int]' % __name__)
1712 u = Union[int, Employee]
1713 self.assertEqual(repr(u), 'typing.Union[int, %s.Employee]' % __name__)
1715 u = Union[T, int][int]
1717 u = Union[List[int], int]
1718 self.assertEqual(repr(u), 'typing.Union[typing.List[int], int]')
1719 u = Union[list[int], dict[str, float]]
1720 self.assertEqual(repr(u), 'typing.Union[list[int], dict[str, float]]')
1721 u = Union[int | float]
1722 self.assertEqual(repr(u), 'typing.Union[int, float]')
1724 u = Union[None, str]
1726 u = Union[str, None]
1728 u = Union[None, str, int]
1729 self.assertEqual(repr(u), 'typing.Union[NoneType, str, int]')
1734 dir_items = set(dir(Union[str, int]))
1743 class C(Union):
1746 class C(type(Union)):
1749 class C(Union[int, str]):
1754 Union()
1756 type(Union)()
1757 u = Union[int, float]
1764 self.assertFalse(Union[str, typing.Iterable[int]] == str)
1765 self.assertFalse(Union[str, typing.Iterable[int]] == typing.Iterable[int])
1766 self.assertIn(str, Union[str, typing.Iterable[int]].__args__)
1767 self.assertIn(typing.Iterable[int], Union[str, typing.Iterable[int]].__args__)
1770 self.assertNotEqual(Union, object)
1771 self.assertNotEqual(Union, Any)
1772 self.assertNotEqual(ClassVar, Union)
1773 self.assertNotEqual(Optional, Union)
1776 self.assertNotEqual(Optional[typing.MutableMapping], Union)
1780 u = Union[int, None]
1785 Union[()]
1788 u = Union[int, str]
1794 self.assertEqual(repr(Union[fun, int]), 'typing.Union[fun, int]')
1798 A = Union[str, Pattern]
1806 Union[Element, str] # Shouldn't crash
1811 Union[Elem, str] # Nor should this
1814 self.assertEqual(Union[Literal[1], Literal[2]].__args__,
1816 self.assertEqual(Union[Literal[1], Literal[1]],
1819 self.assertEqual(Union[Literal[False], Literal[0]].__args__,
1821 self.assertEqual(Union[Literal[True], Literal[1]].__args__,
1829 self.assertEqual(Union[Literal[Ints.A], Literal[Ints.A]],
1831 self.assertEqual(Union[Literal[Ints.B], Literal[Ints.B]],
1834 self.assertEqual(Union[Literal[Ints.A], Literal[Ints.B]].__args__,
1837 self.assertEqual(Union[Literal[0], Literal[Ints.A], Literal[False]].__args__,
1839 self.assertEqual(Union[Literal[1], Literal[Ints.B], Literal[True]].__args__,
1981 self.assertEqual(Callable | Tuple, Union[Callable, Tuple])
1982 self.assertEqual(Tuple | Callable, Union[Tuple, Callable])
3222 Alias = typing.Union[typing.Iterable, P]
3223 Alias2 = typing.Union[P, typing.Iterable]
3635 self.assertEqual(Union[T, int][Meta], Union[Meta, int])
3667 self.assertNotEqual(Union[str, A[str]], Union[str, mod_generics_cache.A[str]])
3668 self.assertNotEqual(Union[A[str], A[str]],
3669 Union[A[str], mod_generics_cache.A[str]])
3688 self.assertEqual(Union[T, int][int], int)
3689 self.assertEqual(Union[T, U][int, Union[int, str]], Union[int, str])
3692 self.assertEqual(Union[T, Base][Union[Base, Derived]], Union[Base, Derived])
3698 self.assertEqual(repr(Union[Tuple, Callable]).replace('typing.', ''),
3699 'Union[Tuple, Callable]')
3700 self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
3701 'Union[Tuple, Tuple[int]]')
3803 List[Union]
3871 samples = [Any, Union, Tuple, Callable, ClassVar,
3872 Union[int, str], ClassVar[List], Tuple[int, ...], Tuple[()],
3891 things = [Union[T, int], Tuple[T, int], Tuple[()],
3896 Union['T', int], List['T'], typing.Mapping['T', int]]
3902 # Special forms like Union, Any, etc., generic aliases to containers like List,
3911 Union, Any, Tuple, Callable]:
3955 things = [Any, Union[T, int], Callable[..., T], Tuple[Any, Any],
4221 Union[int, float],
4453 self.assertEqual(cast(Union[str, float], 42), 42)
4569 self.assertEqual(Union[c1, c1_gth], Union[c1])
4570 self.assertEqual(Union[c1, c1_gth, int], Union[c1, int])
4625 def foo(a: Union['T']):
4629 {'a': Union[T]})
4684 Value = Union[str, ValueList]
4689 foo: Union[Value, ValueList]
4691 foo: Union[List[Value], ValueList]
4693 foo: Union[Value, List[Value], ValueList]
4697 {'foo': List[Union[str, List[Union[str, List['Value']]]]]})
4699 {'foo': Union[str, List[Union[str, List['Value']]]]})
4701 {'foo': Union[
4702 List[Union[str, List[Union[str, List['Value']]]]],
4703 List[Union[str, List['Value']]]
4707 {'foo': Union[
4709 List[Union[str, List['Value']]],
4710 List[Union[str, List[Union[str, List['Value']]]]]
4956 self.assertEqual(X | "x", Union[X, "x"])
4957 self.assertEqual("x" | X, Union["x", X])
5369 y: typing.Union[int, Annotated[T, "mutable"]]): ...
5372 {'x': typing.Callable[..., List[T]], 'y': typing.Union[int, T]}
5544 self.assertIs(get_origin(Union[int, str]), Union)
5573 self.assertEqual(get_args(Union[int, str]), (int, str))
5576 self.assertEqual(get_args(Union[int, Tuple[T, int]][str]),
5582 self.assertEqual(get_args(Union[int, Callable[[Tuple[T, ...]], str]]),
6086 self.assertEqual(typing.Sized | typing.Awaitable, Union[typing.Sized, typing.Awaitable])
6087 self.assertEqual(typing.Coroutine | typing.Hashable, Union[typing.Coroutine, typing.Hashable])
6208 self.assertEqual(UserId | cls, self.module.Union[UserId, cls])
6209 self.assertEqual(cls | UserId, self.module.Union[cls, UserId])
6583 self.assertEqual(typing.Optional[EmpD], typing.Union[None, EmpD])
6768 self.assertIs(is_typeddict(Union[str, int]), False)
7068 Pattern[Union[str, bytes]]
7069 Match[Union[bytes, str]]
7078 m = Match[Union[str, bytes]]
7244 samples = [typing.Any, typing.Union[int, str],
7666 bad_args = (42, int, None, T, int|str, Union[int, str])
8033 typing.Union: 'Union',
8045 typing.Union[Any]: 'Any',
8046 typing.Union[int, float]: 'Union',
8275 Union,
8276 Union[str, int],
8277 Union[str, T],