Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/yarl/_query.py: 22%

1"""Query string handling.""" 

2 

3import math 

4from collections.abc import Iterable, Mapping, Sequence 

5from typing import TYPE_CHECKING, Any, SupportsInt, Union, cast 

6 

7from multidict import istr 

8 

9from ._quoters import QUERY_PART_QUOTER, QUERY_QUOTER 

10 

11SimpleQuery = Union[str, SupportsInt, float] 

12QueryVariable = Union[SimpleQuery, Sequence[SimpleQuery]] 

13Query = Union[ 

14 None, str, Mapping[str, QueryVariable], Sequence[tuple[str, QueryVariable]] 

15] 

16 

17 

18def query_var(v: SimpleQuery) -> str: 

19 """Convert a query variable to a string.""" 

20 cls = type(v) 

21 if cls is int: # Fast path for non-subclassed int 

22 return str(v) 

23 if isinstance(v, str): 

24 return v 

25 if isinstance(v, float): 

26 if math.isinf(v): 

27 raise ValueError("float('inf') is not supported") 

28 if math.isnan(v): 

29 raise ValueError("float('nan') is not supported") 

30 return str(float(v)) 

31 if cls is not bool and isinstance(v, SupportsInt): 

32 return str(int(v)) 

33 raise TypeError( 

34 "Invalid variable type: value " 

35 "should be str, int or float, got {!r} " 

36 "of type {}".format(v, cls) 

37 ) 

38 

39 

40def get_str_query_from_sequence_iterable( 

41 items: Iterable[tuple[Union[str, istr], QueryVariable]], 

42) -> str: 

43 """Return a query string from a sequence of (key, value) pairs. 

44 

45 value is a single value or a sequence of values for the key 

46 

47 The sequence of values must be a list or tuple. 

48 """ 

49 quoter = QUERY_PART_QUOTER 

50 pairs = [ 

51 f"{quoter(k)}={quoter(v if type(v) is str else query_var(v))}" 

52 for k, val in items 

53 for v in ( 

54 val if type(val) is not str and isinstance(val, (list, tuple)) else (val,) 

55 ) 

56 ] 

57 return "&".join(pairs) 

58 

59 

60def get_str_query_from_iterable( 

61 items: Iterable[tuple[Union[str, istr], SimpleQuery]], 

62) -> str: 

63 """Return a query string from an iterable. 

64 

65 The iterable must contain (key, value) pairs. 

66 

67 The values are not allowed to be sequences, only single values are 

68 allowed. For sequences, use `_get_str_query_from_sequence_iterable`. 

69 """ 

70 quoter = QUERY_PART_QUOTER 

71 # A listcomp is used since listcomps are inlined on CPython 3.12+ and 

72 # they are a bit faster than a generator expression. 

73 pairs = [ 

74 f"{quoter(k)}={quoter(v if type(v) is str else query_var(v))}" for k, v in items 

75 ] 

76 return "&".join(pairs) 

77 

78 

79def get_str_query(*args: Any, **kwargs: Any) -> Union[str, None]: 

80 """Return a query string from supported args.""" 

81 query: Union[ 

82 str, 

83 Mapping[str, QueryVariable], 

84 Sequence[tuple[Union[str, istr], SimpleQuery]], 

85 None, 

86 ] 

87 if kwargs: 

88 if args: 

89 msg = "Either kwargs or single query parameter must be present" 

90 raise ValueError(msg) 

91 query = kwargs 

92 elif len(args) == 1: 

93 query = args[0] 

94 else: 

95 raise ValueError("Either kwargs or single query parameter must be present") 

96 

97 if query is None: 

98 return None 

99 if not query: 

100 return "" 

101 if type(query) is dict: 

102 return get_str_query_from_sequence_iterable(query.items()) 

103 if type(query) is str or isinstance(query, str): 

104 return QUERY_QUOTER(query) 

105 if isinstance(query, Mapping): 

106 return get_str_query_from_sequence_iterable(query.items()) 

107 if isinstance(query, (bytes, bytearray, memoryview)): 

108 msg = "Invalid query type: bytes, bytearray and memoryview are forbidden" 

109 raise TypeError(msg) 

110 if isinstance(query, Sequence): 

111 # We don't expect sequence values if we're given a list of pairs 

112 # already; only mappings like builtin `dict` which can't have the 

113 # same key pointing to multiple values are allowed to use 

114 # `_query_seq_pairs`. 

115 if TYPE_CHECKING: 

116 query = cast(Sequence[tuple[Union[str, istr], SimpleQuery]], query) 

117 return get_str_query_from_iterable(query) 

118 raise TypeError( 

119 "Invalid query type: only str, mapping or " 

120 "sequence of (key, value) pairs is allowed" 

121 )