Coverage for /var/srv/projects/api.amasfac.comuna18.com/tmp/venv/lib/python3.9/site-packages/django_filters/rest_framework/backends.py: 51%

1import warnings 

2 

3from django.template import loader 

4 

5from .. import compat, utils 

6from . import filters, filterset 

7 

8 

9class DjangoFilterBackend: 

10 filterset_base = filterset.FilterSet 

11 raise_exception = True 

12 

13 @property 

14 def template(self): 

15 if compat.is_crispy(): 

16 return "django_filters/rest_framework/crispy_form.html" 

17 return "django_filters/rest_framework/form.html" 

18 

19 def get_filterset(self, request, queryset, view): 

20 filterset_class = self.get_filterset_class(view, queryset) 

21 if filterset_class is None: 

22 return None 

23 

24 kwargs = self.get_filterset_kwargs(request, queryset, view) 

25 return filterset_class(**kwargs) 

26 

27 def get_filterset_class(self, view, queryset=None): 

28 """ 

29 Return the `FilterSet` class used to filter the queryset. 

30 """ 

31 filterset_class = getattr(view, "filterset_class", None) 

32 filterset_fields = getattr(view, "filterset_fields", None) 

33 

34 if filterset_class: 

35 filterset_model = filterset_class._meta.model 

36 

37 # FilterSets do not need to specify a Meta class 

38 if filterset_model and queryset is not None: 38 ↛ 46line 38 didn't jump to line 46, because the condition on line 38 was never false

39 assert issubclass( 

40 queryset.model, filterset_model 

41 ), "FilterSet model %s does not match queryset model %s" % ( 

42 filterset_model, 

43 queryset.model, 

44 ) 

45 

46 return filterset_class 

47 

48 if filterset_fields and queryset is not None: 

49 MetaBase = getattr(self.filterset_base, "Meta", object) 

50 

51 class AutoFilterSet(self.filterset_base): 

52 class Meta(MetaBase): 

53 model = queryset.model 

54 fields = filterset_fields 

55 

56 return AutoFilterSet 

57 

58 return None 

59 

60 def get_filterset_kwargs(self, request, queryset, view): 

61 return { 

62 "data": request.query_params, 

63 "queryset": queryset, 

64 "request": request, 

65 } 

66 

67 def filter_queryset(self, request, queryset, view): 

68 filterset = self.get_filterset(request, queryset, view) 

69 if filterset is None: 

70 return queryset 

71 

72 if not filterset.is_valid() and self.raise_exception: 72 ↛ 73line 72 didn't jump to line 73, because the condition on line 72 was never true

73 raise utils.translate_validation(filterset.errors) 

74 return filterset.qs 

75 

76 def to_html(self, request, queryset, view): 

77 filterset = self.get_filterset(request, queryset, view) 

78 if filterset is None: 

79 return None 

80 

81 template = loader.get_template(self.template) 

82 context = {"filter": filterset} 

83 return template.render(context, request) 

84 

85 def get_coreschema_field(self, field): 

86 if isinstance(field, filters.NumberFilter): 

87 field_cls = compat.coreschema.Number 

88 else: 

89 field_cls = compat.coreschema.String 

90 return field_cls(description=str(field.extra.get("help_text", ""))) 

91 

92 def get_schema_fields(self, view): 

93 # This is not compatible with widgets where the query param differs from the 

94 # filter's attribute name. Notably, this includes `MultiWidget`, where query 

95 # params will be of the format `<name>_0`, `<name>_1`, etc... 

96 assert ( 

97 compat.coreapi is not None 

98 ), "coreapi must be installed to use `get_schema_fields()`" 

99 assert ( 

100 compat.coreschema is not None 

101 ), "coreschema must be installed to use `get_schema_fields()`" 

102 

103 try: 

104 queryset = view.get_queryset() 

105 except Exception: 

106 queryset = None 

107 warnings.warn( 

108 "{} is not compatible with schema generation".format(view.__class__) 

109 ) 

110 

111 filterset_class = self.get_filterset_class(view, queryset) 

112 

113 return ( 

114 [] 

115 if not filterset_class 

116 else [ 

117 compat.coreapi.Field( 

118 name=field_name, 

119 required=field.extra["required"], 

120 location="query", 

121 schema=self.get_coreschema_field(field), 

122 ) 

123 for field_name, field in filterset_class.base_filters.items() 

124 ] 

125 ) 

126 

127 def get_schema_operation_parameters(self, view): 

128 try: 

129 queryset = view.get_queryset() 

130 except Exception: 

131 queryset = None 

132 warnings.warn( 

133 "{} is not compatible with schema generation".format(view.__class__) 

134 ) 

135 

136 filterset_class = self.get_filterset_class(view, queryset) 

137 

138 if not filterset_class: 

139 return [] 

140 

141 parameters = [] 

142 for field_name, field in filterset_class.base_filters.items(): 

143 parameter = { 

144 "name": field_name, 

145 "required": field.extra["required"], 

146 "in": "query", 

147 "description": field.label if field.label is not None else field_name, 

148 "schema": { 

149 "type": "string", 

150 }, 

151 } 

152 if field.extra and "choices" in field.extra: 

153 parameter["schema"]["enum"] = [c[0] for c in field.extra["choices"]] 

154 parameters.append(parameter) 

155 return parameters