pumpwood_communication.microservice_abc.parallel

 8class ABCParallelActionMicroservice(ABCParallelBaseMicroservice):
 9    """Abstract class for parallel calls at Pumpwood end-points."""
10
11    def parallel_execute_action(self, model_class: Union[str, list[str]],
12                                list_pk: list[int],
13                                action: str | list[str],
14                                parameters: dict | list[dict] = {},
15                                n_parallel: int = None,
16                                auth_header: dict = None,
17                                base_filter_skip: list[str] | list[list[str]] = None # NOQA
18                                ) -> list[dict]:
19        """Make [n_parallel] parallel execute_action requests.
20
21        Args:
22            model_class:
23                Model Class to perform action over,
24                or a list of model class o make diferent actions.
25            list_pk:
26                A list of the pks to perform action or a
27                single pk to perform action with different paraemters.
28            action:
29                A list of actions to perform or a single
30                action to perform over all pks and parameters.
31            parameters:
32                Parameters used to perform actions
33                or a single dict to be used in all actions.
34            n_parallel:
35                Number of simultaneous requests. If not set, uses
36                ``PUMPWOOD_COMMUNICATION__N_PARALLEL`` env variable
37                (legacy spelling supported), default 4.
38            auth_header:
39                Auth header to substitute the microservice original
40                at the request (user impersonation).
41            base_filter_skip (list[str] | list[list[str]]):
42                List of base query filter to be skiped, it is necessary to
43                be superuser to skip base query filters.
44
45        Returns:
46            list of the execute_action request data.
47
48        Raises:
49            PumpWoodException:
50                'parallel_length != len([argument])'. Indicates that function
51                arguments does not have all the same length.
52
53        Example:
54            No example yet.
55        """
56        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
57
58        list_model_class = self.convert_to_list(
59            argument=model_class, length=len(list_pk))
60        list_action = self.convert_to_list(
61            argument=action, length=len(list_pk))
62        list_parameters = self.convert_to_list(
63            argument=parameters, length=len(list_pk))
64        list_auth_header = self.convert_to_list(
65            argument=auth_header, length=len(list_pk))
66        list_base_filter_skip = self.convert_to_list(
67            argument=base_filter_skip, length=len(list_pk),
68            force_replicate=True)
69        column_arg = {
70            'model_class': list_model_class,
71            'action': list_action,
72            'parameters': list_parameters,
73            'auth_header': list_auth_header,
74            'base_filter_skip': list_base_filter_skip}
75
76        function_args = self.transpose_args(dict_list=column_arg)
77        return self.parallel_call(
78            function=self.execute_action, function_args=function_args,
79            n_parallel=n_parallel)

  8class ABCParallelDeleteMicroservice(ABCParallelBaseMicroservice):
  9    """Abstract class for parallel calls at Pumpwood end-points."""
 10
 11    def parallel_delete(self, model_class: Union[str, list[str]],
 12                        list_pk: list[int], n_parallel: int = None,
 13                        auth_header: dict = None,
 14                        base_filter_skip: list[str] | list[list[str]] = None):
 15        """Make many [n_parallel] delete requests.
 16
 17        Args:
 18            model_class:
 19                Model Class to list one.
 20            list_pk:
 21                List of the pks to list one.
 22            n_parallel:
 23                Number of simultaneous requests. If not set, uses
 24                ``PUMPWOOD_COMMUNICATION__N_PARALLEL`` env variable
 25                (legacy spelling supported), default 4.
 26            auth_header:
 27                Auth header to substitute the microservice original
 28                at the request (user impersonation).
 29            base_filter_skip (list):
 30                List of base query filter to be skiped, it is necessary to
 31                be superuser to skip base query filters.
 32
 33        Returns:
 34            List of the delete request data.
 35
 36        Raises:
 37            PumpWoodException:
 38                'len(model_class)[{}] != len(list_args)[{}]'. Indicates
 39                that length of model_class and list_args arguments are not
 40                equal.
 41        """
 42        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
 43
 44        list_model_class = self.convert_to_list(
 45            argument=model_class, length=len(list_pk))
 46        list_auth_header = self.convert_to_list(
 47            argument=auth_header, length=len(list_pk))
 48        list_base_filter_skip = self.convert_to_list(
 49            argument=base_filter_skip, length=len(list_pk),
 50            force_replicate=True)
 51        column_arg = {
 52            'model_class': list_model_class,
 53            'auth_header': list_auth_header,
 54            'base_filter_skip': list_base_filter_skip,
 55            'pk': list_pk}
 56
 57        function_args = self.transpose_args(dict_list=column_arg)
 58        return self.parallel_call(
 59            function=self.delete, function_args=function_args,
 60            n_parallel=n_parallel)
 61
 62    def parallel_delete_many(self, model_class: Union[str, List[str]],
 63                             list_args: List[dict], n_parallel: int = None,
 64                             auth_header: dict = None,
 65                             base_filter_skip: list[str] | list[list[str]] = None # NOQA
 66                             ) -> List[dict]:
 67        """Make [n_parallel] parallel delete_many request.
 68
 69        Args:
 70            model_class (str):
 71                Model Class to delete many.
 72            list_args (list):
 73                A list of list request args (filter_dict, exclude_dict).
 74            n_parallel:
 75                Number of simultaneous requests. If not set, uses
 76                ``PUMPWOOD_COMMUNICATION__N_PARALLEL`` env variable
 77                (legacy spelling supported), default 4.
 78            auth_header:
 79                Auth header to substitute the microservice original
 80                at the request (user impersonation).
 81            base_filter_skip (list):
 82                List of base query filter to be skiped, it is necessary to
 83                be superuser to skip base query filters.
 84
 85        Returns:
 86            List of the delete many request reponses.
 87
 88        Raises:
 89            PumpWoodException:
 90                'len(model_class)[{}] != len(list_args)[{}]'. Indicates
 91                that length of model_class and list_args arguments
 92                are not equal.
 93
 94        Example:
 95            No example yet.
 96        """
 97        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
 98
 99        dict_list = self.expand_list_args(
100            list_args=list_args, keys=['filter_dict', 'exclude_dict'])
101        list_model_class = self.convert_to_list(
102            argument=model_class, length=len(list_args))
103        list_auth_header = self.convert_to_list(
104            argument=auth_header, length=len(list_args))
105        list_base_filter_skip = self.convert_to_list(
106            argument=base_filter_skip, length=len(list_args),
107            force_replicate=True)
108        column_arg = {
109            'model_class': list_model_class,
110            'auth_header': list_auth_header,
111            'base_filter_skip': list_base_filter_skip}
112        column_arg.update(dict_list)
113
114        function_args = self.transpose_args(dict_list=column_arg)
115        return self.parallel_call(
116            function=self.delete_many, function_args=function_args,
117            n_parallel=n_parallel)

  8class ABCParallelListMicroservice(ABCParallelBaseMicroservice):
  9    """Abstract class for parallel calls at Pumpwood end-points."""
 10
 11    def parallel_list(self, model_class: Union[str, List[str]],
 12                      list_args: List[dict],
 13                      auth_header: dict = None, fields: list = None,
 14                      default_fields: bool = False, limit: int = None,
 15                      foreign_key_fields: bool = False,
 16                      base_filter_skip: list = None,
 17                      n_parallel: int = None,
 18                      flat_results: bool = True,
 19                      as_dataframe: bool = False) -> List[dict]:
 20        """List objects with pagination.
 21
 22        Args:
 23            model_class:
 24                Model class of the end-point
 25            list_args:
 26                filter_dict:
 27                    Filter dict to be used at the query. Filter elements from
 28                    query return that satifies all statements of the dictonary.
 29                exclude_dict:
 30                    Exclude dict to be used at the query. Remove elements from
 31                    query return that satifies all statements of the dictonary.
 32                order_by: Order results acording to list of strings
 33                    correspondent to fields. It is possible to use '-' at the
 34                    begginng of the field name for reverse ordering. Ex.:
 35                    ['description'] for accendent ordering and ['-description']
 36                    for descendent ordering.
 37            auth_header:
 38                Auth header to substitute the microservice original
 39                at the request (user impersonation).
 40            fields (list):
 41                Set the fields to be returned by the list end-point.
 42            default_fields (bool):
 43                Boolean, if true and fields arguments None will return the
 44                default fields set for list by the backend.
 45            limit (int):
 46                Set the limit of elements of the returned query. By default,
 47                backend usually return 50 elements.
 48            foreign_key_fields (bool):
 49                Return forenging key objects. It will return the fk
 50                corresponding object. Ex: `created_by_id` reference to
 51                a user `model_class` the correspondent to User will be
 52                returned at `created_by`.
 53            base_filter_skip (list):
 54                List of base query filter to be skiped, it is necessary to
 55                be superuser to skip base query filters.
 56            n_parallel (int):
 57                Number of parallel requests, if None will use the default
 58                one.
 59            flat_results (bool):
 60                The results will be joined on a single list.
 61            as_dataframe (bool):
 62                If True, returns the results as a pandas DataFrame.
 63
 64        Returns:
 65          Containing objects serialized by list Serializer.
 66
 67        Raises:
 68          No especific raises.
 69        """ # NOQA
 70        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
 71
 72        # Convert arguments to list
 73        dict_list = self.expand_list_args(list_args=list_args)
 74        list_model_class = self.convert_to_list(
 75            argument=model_class, length=len(list_args))
 76        list_auth_header = self.convert_to_list(
 77            argument=auth_header, length=len(list_args))
 78        list_fields = self.convert_to_list(
 79            argument=fields, length=len(list_args),
 80            force_replicate=True)
 81        list_default_fields = self.convert_to_list(
 82            argument=default_fields, length=len(list_args))
 83        list_limit = self.convert_to_list(
 84            argument=limit, length=len(list_args))
 85        list_foreign_key_fields = self.convert_to_list(
 86            argument=foreign_key_fields, length=len(list_args))
 87        list_base_filter_skip = self.convert_to_list(
 88            argument=base_filter_skip, length=len(list_args),
 89            force_replicate=True)
 90        list_as_dataframe = self.convert_to_list(
 91            argument=as_dataframe, length=len(list_args),
 92            force_replicate=True)
 93
 94        column_arg = {
 95            'model_class': list_model_class,
 96            'auth_header': list_auth_header,
 97            'fields': list_fields,
 98            'default_fields': list_default_fields,
 99            'limit': list_limit,
100            'foreign_key_fields': list_foreign_key_fields,
101            'base_filter_skip': list_base_filter_skip,
102            "as_dataframe": list_as_dataframe
103        }
104        column_arg.update(dict_list)
105
106        function_args = self.transpose_args(dict_list=column_arg)
107        parallel_results = self.parallel_call(
108            function=self.list, function_args=function_args,
109            n_parallel=n_parallel)
110        if flat_results:
111            return self.flatten_parallel(parallel_results)
112        else:
113            return parallel_results
114
115    def parallel_list_without_pag(self, model_class: Union[str, List[str]],
116                                  list_args: List[dict],
117                                  auth_header: dict = None,
118                                  fields: list = None,
119                                  default_fields: bool = False,
120                                  foreign_key_fields: bool = False,
121                                  base_filter_skip: list = None,
122                                  n_parallel: int = None,
123                                  flat_results: bool = True,
124                                  as_dataframe: bool = False) -> List[dict]:
125        """List objects with pagination.
126
127        Args:
128            model_class:
129                Model class of the end-point
130            list_args:
131                filter_dict:
132                    Filter dict to be used at the query. Filter elements from
133                    query return that satifies all statements of the dictonary.
134                exclude_dict:
135                    Exclude dict to be used at the query. Remove elements from
136                    query return that satifies all statements of the dictonary.
137            auth_header:
138                Auth header to substitute the microservice original
139                at the request (user impersonation).
140            fields (list):
141                Set the fields to be returned by the list end-point.
142            default_fields (bool):
143                Boolean, if true and fields arguments None will return the
144                default fields set for list by the backend.
145            foreign_key_fields (bool):
146                Return forenging key objects. It will return the fk
147                corresponding object. Ex: `created_by_id` reference to
148                a user `model_class` the correspondent to User will be
149                returned at `created_by`.
150            base_filter_skip (list):
151                List of base query filter to be skiped, it is necessary to
152                be superuser to skip base query filters.
153            n_parallel (int):
154                Number of parallel requests, if None will use the default
155                one.
156            flat_results (bool):
157                The results will be joined on a single list.
158            as_dataframe (bool):
159                If True, returns the results as a pandas DataFrame.
160
161        Returns:
162          Containing objects serialized by list Serializer.
163
164        Raises:
165          No especific raises.
166        """ # NOQA
167        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
168
169        # Convert arguments to list
170        dict_list = self.expand_list_args(
171            list_args=list_args, keys=['filter_dict', 'exclude_dict'])
172        list_model_class = self.convert_to_list(
173            argument=model_class, length=len(list_args))
174        list_auth_header = self.convert_to_list(
175            argument=auth_header, length=len(list_args))
176        list_fields = self.convert_to_list(
177            argument=fields, length=len(list_args),
178            force_replicate=True)
179        list_default_fields = self.convert_to_list(
180            argument=default_fields, length=len(list_args))
181        list_foreign_key_fields = self.convert_to_list(
182            argument=foreign_key_fields, length=len(list_args))
183        list_base_filter_skip = self.convert_to_list(
184            argument=base_filter_skip, length=len(list_args),
185            force_replicate=True)
186        list_as_dataframe = self.convert_to_list(
187            argument=as_dataframe, length=len(list_args),
188            force_replicate=True)
189
190        column_arg = {
191            'model_class': list_model_class,
192            'auth_header': list_auth_header,
193            'fields': list_fields,
194            'default_fields': list_default_fields,
195            'foreign_key_fields': list_foreign_key_fields,
196            'base_filter_skip': list_base_filter_skip,
197            "as_dataframe": list_as_dataframe
198        }
199        column_arg.update(dict_list)
200
201        function_args = self.transpose_args(dict_list=column_arg)
202        parallel_results = self.parallel_call(
203            function=self.list_without_pag, function_args=function_args,
204            n_parallel=n_parallel)
205        if flat_results:
206            return self.flatten_parallel(
207                parallel_results, as_dataframe=as_dataframe)
208        else:
209            return parallel_results
210
211    def parallel_list_by_chunks(self, model_class: Union[str, List[str]],
212                                list_args: List[dict],
213                                auth_header: dict = None,
214                                fields: list = None,
215                                default_fields: bool = False,
216                                foreign_key_fields: bool = False,
217                                base_filter_skip: list = None,
218                                n_parallel: int = None,
219                                chunk_size: int = 50000,
220                                flat_results: bool = True,
221                                as_dataframe: bool = False) -> List[dict]:
222        """List objects by chunks.
223
224        Order by arguments on list by chunks will be ignored.
225
226        Args:
227            model_class:
228                Model class of the end-point
229            list_args:
230                filter_dict:
231                    Filter dict to be used at the query. Filter elements from
232                    query return that satifies all statements of the dictonary.
233                exclude_dict:
234                    Exclude dict to be used at the query. Remove elements from
235                    query return that satifies all statements of the dictonary.
236            auth_header:
237                Auth header to substitute the microservice original
238                at the request (user impersonation).
239            fields (list):
240                Set the fields to be returned by the list end-point.
241            default_fields (bool):
242                Boolean, if true and fields arguments None will return the
243                default fields set for list by the backend.
244            foreign_key_fields (bool):
245                Return forenging key objects. It will return the fk
246                corresponding object. Ex: `created_by_id` reference to
247                a user `model_class` the correspondent to User will be
248                returned at `created_by`.
249            base_filter_skip (list):
250                List of base query filter to be skiped, it is necessary to
251                be superuser to skip base query filters.
252            n_parallel (int):
253                Number of parallel requests, if None will use the default
254                one.
255            flat_results (bool):
256                The results will be joined on a single list.
257            as_dataframe (bool):
258                If True, returns the results as a pandas DataFrame.
259            chunk_size (int):
260                Number of objects to fetch per query. Defaults to 50000.
261
262        Returns:
263          Containing objects serialized by list Serializer.
264
265        Raises:
266          No especific raises.
267        """ # NOQA
268        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
269
270        # Convert arguments to list
271        dict_list = self.expand_list_args(
272            list_args=list_args, keys=['filter_dict', 'exclude_dict'])
273        list_model_class = self.convert_to_list(
274            argument=model_class, length=len(list_args))
275        list_auth_header = self.convert_to_list(
276            argument=auth_header, length=len(list_args))
277        list_fields = self.convert_to_list(
278            argument=fields, length=len(list_args),
279            force_replicate=True)
280        list_default_fields = self.convert_to_list(
281            argument=default_fields, length=len(list_args))
282        list_foreign_key_fields = self.convert_to_list(
283            argument=foreign_key_fields, length=len(list_args))
284        list_base_filter_skip = self.convert_to_list(
285            argument=base_filter_skip, length=len(list_args),
286            force_replicate=True)
287        list_chunk_size = self.convert_to_list(
288            argument=chunk_size, length=len(list_args),
289            force_replicate=True)
290        list_as_dataframe = self.convert_to_list(
291            argument=as_dataframe, length=len(list_args),
292            force_replicate=True)
293
294        column_arg = {
295            'model_class': list_model_class,
296            'auth_header': list_auth_header,
297            'fields': list_fields,
298            'default_fields': list_default_fields,
299            'foreign_key_fields': list_foreign_key_fields,
300            'base_filter_skip': list_base_filter_skip,
301            "chunk_size": list_chunk_size,
302            "as_dataframe": list_as_dataframe
303        }
304        column_arg.update(dict_list)
305
306        function_args = self.transpose_args(dict_list=column_arg)
307        parallel_results = self.parallel_call(
308            function=self.list_by_chunks, function_args=function_args,
309            n_parallel=n_parallel)
310        if flat_results:
311            return self.flatten_parallel(
312                parallel_results, as_dataframe=as_dataframe)
313        else:
314            return parallel_results

  7class ABCParallelRetriveMicroservice(ABCParallelBaseMicroservice):
  8    """Abstract class for parallel calls at Pumpwood end-points."""
  9
 10    def parallel_retrieve(self, model_class: str | list[str],
 11                          list_pk: list[int],
 12                          default_fields: bool | list[bool] = False,
 13                          foreign_key_fields: bool | list[bool] = False,
 14                          related_fields: bool | list[bool] = False,
 15                          fields: list[str] | list[list[str]] = None,
 16                          auth_header: dict | list[dict] = None,
 17                          use_disk_cache: bool | list[bool] = False,
 18                          use_app_cache: bool | list[bool] = False,
 19                          disk_cache_expire: int | list[int] = None,
 20                          base_filter_skip: list[str] | list[list[str]] = None,
 21                          n_parallel: int | None = None,
 22                          ) -> list[dict]:
 23        """Retrieve an object from PumpWood.
 24
 25        Function to get object serialized by retrieve end-point
 26        (more detailed data).
 27
 28        Args:
 29            model_class:
 30                Model class of the end-point
 31            list_pk:
 32                Object pk
 33            auth_header:
 34                Auth header to substitute the microservice original
 35                at the request (user impersonation).
 36            fields:
 37                Set the fields to be returned by the list end-point.
 38            default_fields:
 39                Boolean, if true and fields arguments None will return the
 40                default fields set for list by the backend.
 41            foreign_key_fields:
 42                Return forenging key objects. It will return the fk
 43                corresponding object. Ex: `created_by_id` reference to
 44                a user `model_class` the correspondent to User will be
 45                returned at `created_by`.
 46            related_fields:
 47                Return related fields objects. Related field objects are
 48                objects that have a forenging key associated with this
 49                model_class, results will be returned as a list of
 50                dictionaries usually in a field with `_set` at end.
 51                Returning related_fields consume backend resorces, use
 52                carefully.
 53            use_disk_cache (bool):
 54                If set true, get request will use local cache to reduce
 55                the requests to the backend.
 56            use_app_cache (bool):
 57                If True, the GET request will use the cache of the application.
 58                Defaults to False.
 59            disk_cache_expire (int):
 60                Time in seconds to expire the cache, it None it will
 61                use de default set be PumpwoodCache.
 62            base_filter_skip (list):
 63                List of base query filter to be skiped, it is necessary to
 64                be superuser to skip base query filters.
 65            n_parallel (int | None):
 66                N parallel request that will be done on backend.
 67
 68        Returns:
 69            Return object with the correspondent pk.
 70
 71        Raises:
 72            PumpWoodObjectDoesNotExist:
 73                If pk not found on database.
 74        """
 75        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
 76
 77        list_model_class = self.convert_to_list(
 78            argument=model_class, length=len(list_pk))
 79        list_default_fields = self.convert_to_list(
 80            argument=default_fields, length=len(list_pk))
 81        list_foreign_key_fields = self.convert_to_list(
 82            argument=foreign_key_fields, length=len(list_pk))
 83        list_related_fields = self.convert_to_list(
 84            argument=related_fields, length=len(list_pk))
 85        list_fields = self.convert_to_list(
 86            argument=fields, length=len(list_pk),
 87            force_replicate=True)
 88        list_auth_header = self.convert_to_list(
 89            argument=auth_header, length=len(list_pk))
 90        list_use_disk_cache = self.convert_to_list(
 91            argument=use_disk_cache, length=len(list_pk))
 92        list_use_app_cache = self.convert_to_list(
 93            argument=use_app_cache, length=len(list_pk))
 94        list_disk_cache_expire = self.convert_to_list(
 95            argument=disk_cache_expire, length=len(list_pk))
 96        list_base_filter_skip = self.convert_to_list(
 97            argument=base_filter_skip, length=len(list_pk),
 98            force_replicate=True)
 99
100        column_arg = {
101            'model_class': list_model_class,
102            'pk': list_pk,
103            'default_fields': list_default_fields,
104            'foreign_key_fields': list_foreign_key_fields,
105            'related_fields': list_related_fields,
106            'fields': list_fields,
107            'auth_header': list_auth_header,
108            'use_disk_cache': list_use_disk_cache,
109            'use_app_cache': list_use_app_cache,
110            'disk_cache_expire': list_disk_cache_expire,
111            'base_filter_skip': list_base_filter_skip}
112
113        function_args = self.transpose_args(dict_list=column_arg)
114        return self.parallel_call(
115            function=self.retrieve, function_args=function_args,
116            n_parallel=n_parallel)
117
118    def parallel_list_one(self, model_class: str | list[str],
119                          list_pk: list[int],
120                          default_fields: bool | list[bool] = True,
121                          foreign_key_fields: bool | list[bool] = False,
122                          related_fields: bool | list[bool] = False,
123                          fields: list[str] | list[list[str]] = None,
124                          auth_header: dict | list[dict] = None,
125                          use_disk_cache: bool | list[bool] = False,
126                          use_app_cache: bool | list[bool] = False,
127                          disk_cache_expire: int | list[int] = None,
128                          base_filter_skip: list[str] | list[list[str]] = None,
129                          n_parallel: int | None = None
130                          ) -> list[dict]:
131        """Retrieve an object from PumpWood.
132
133        Function to get object serialized by retrieve end-point
134        (more detailed data).
135
136        Args:
137            model_class:
138                Model class of the end-point
139            list_pk:
140                Object pk
141            auth_header:
142                Auth header to substitute the microservice original
143                at the request (user impersonation).
144            fields:
145                Set the fields to be returned by the list end-point.
146            default_fields:
147                Boolean, if true and fields arguments None will return the
148                default fields set for list by the backend.
149            foreign_key_fields:
150                Return forenging key objects. It will return the fk
151                corresponding object. Ex: `created_by_id` reference to
152                a user `model_class` the correspondent to User will be
153                returned at `created_by`.
154            related_fields:
155                Return related fields objects. Related field objects are
156                objects that have a forenging key associated with this
157                model_class, results will be returned as a list of
158                dictionaries usually in a field with `_set` at end.
159                Returning related_fields consume backend resorces, use
160                carefully.
161            use_disk_cache (bool):
162                If set true, get request will use local cache to reduce
163                the requests to the backend.
164            use_app_cache (bool):
165                If True, the GET request will use the cache of the application.
166                Defaults to False.
167            disk_cache_expire (int):
168                Time in seconds to expire the cache, it None it will
169                use de default set be PumpwoodCache.
170            base_filter_skip (list):
171                List of base query filter to be skiped, it is necessary to
172                be superuser to skip base query filters.
173            n_parallel (int | None):
174                N parallel request that will be done on backend.
175
176        Returns:
177            Return object with the correspondent pk.
178
179        Raises:
180            PumpWoodObjectDoesNotExist:
181                If pk not found on database.
182        """
183        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
184
185        list_model_class = self.convert_to_list(
186            argument=model_class, length=len(list_pk))
187        list_default_fields = self.convert_to_list(
188            argument=default_fields, length=len(list_pk))
189        list_foreign_key_fields = self.convert_to_list(
190            argument=foreign_key_fields, length=len(list_pk))
191        list_related_fields = self.convert_to_list(
192            argument=related_fields, length=len(list_pk))
193        list_fields = self.convert_to_list(
194            argument=fields, length=len(list_pk),
195            force_replicate=True)
196        list_auth_header = self.convert_to_list(
197            argument=auth_header, length=len(list_pk))
198        list_use_disk_cache = self.convert_to_list(
199            argument=use_disk_cache, length=len(list_pk))
200        list_use_app_cache = self.convert_to_list(
201            argument=use_app_cache, length=len(list_pk))
202        list_disk_cache_expire = self.convert_to_list(
203            argument=disk_cache_expire, length=len(list_pk))
204        list_base_filter_skip = self.convert_to_list(
205            argument=base_filter_skip, length=len(list_pk),
206            force_replicate=True)
207
208        column_arg = {
209            'model_class': list_model_class,
210            'pk': list_pk,
211            'default_fields': list_default_fields,
212            'foreign_key_fields': list_foreign_key_fields,
213            'related_fields': list_related_fields,
214            'fields': list_fields,
215            'auth_header': list_auth_header,
216            'use_disk_cache': list_use_disk_cache,
217            'use_app_cache': list_use_app_cache,
218            'disk_cache_expire': list_disk_cache_expire,
219            'base_filter_skip': list_base_filter_skip}
220
221        function_args = self.transpose_args(dict_list=column_arg)
222        return self.parallel_call(
223            function=self.list_one, function_args=function_args,
224            n_parallel=n_parallel)
225
226    def parallel_retrieve_file(self, model_class: str | list[str],
227                               list_pk: list[int],
228                               file_field: str | list[str],
229                               auth_header: dict | list[dict] = None,
230                               save_file: bool | list[bool] = True,
231                               save_path: str | list[str] = "./",
232                               file_name: str | list[str] = None,
233                               if_exists: str | list[str] = "fail",
234                               base_filter_skip: list[str] | list[list[str]] = None,  #NOQA
235                               n_parallel: int | None = None
236                               ) -> list[str] | list[dict]:
237        """Retrieve a file from PumpWood.
238
239        This function will retrieve file as a single request, depending on the
240        size of the files it would be preferred to use streaming end-point.
241
242        Args:
243            model_class:
244                Class of the model to retrieve file.
245            list_pk:
246                Pk of the object associeted file.
247            file_field:
248                Field of the file to be downloaded.
249            auth_header:
250                Dictionary containing the auth header.
251            save_file:
252                If data is to be saved as file or return get
253                response.
254            save_path:
255                Path of the directory to save file.
256            file_name:
257                Name of the file, if None it will have same name as
258                saved in PumpWood.
259            if_exists:
260                Values must be in {'fail', 'change_name', 'overwrite', 'skip'}.
261                Set what to do if there is a file with same name. Skip
262                will not download file if there is already with same
263                os.path.join(save_path, file_name), file_name must be set
264                for skip argument.
265            auth_header:
266                Auth header to substitute the microservice original
267                at the request (user impersonation).
268            base_filter_skip (list):
269                List of base query filter to be skiped, it is necessary to
270                be superuser to skip base query filters.
271            n_parallel (int):
272                Number of parallel requests, if None will use the default
273                one.
274
275        Returns:
276            May return the file name if save_file=True; If false will return
277            a dictonary with keys `filename` with original file name and
278            `content` with binary data of file content.
279
280        Raises:
281            PumpWoodForbidden:
282                'storage_object attribute not set for view, file operations
283                are disable'. This indicates that storage for this backend
284                was not configured, so it is not possible to make storage
285                operations,
286            PumpWoodForbidden:
287                'file_field must be set on self.file_fields dictionary'. This
288                indicates that the `file_field` parameter is not listed as
289                a file field on the backend.
290            PumpWoodObjectDoesNotExist:
291                'field [{}] not found or null at object'. This indicates that
292                the file field requested is not present on object fields.
293            PumpWoodObjectDoesNotExist:
294                'Object not found in storage [{}]'. This indicates that the
295                file associated with file_field is not avaiable at the
296                storage. This should not ocorrur, it might have a manual
297                update at the model_class table or manual removal/rename of
298                files on storage.
299        """
300        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
301
302        # Convert arguments to list
303        list_model_class = self.convert_to_list(
304            argument=model_class, length=len(list_pk))
305        list_file_field = self.convert_to_list(
306            argument=file_field, length=len(list_pk))
307        list_auth_header = self.convert_to_list(
308            argument=auth_header, length=len(list_pk))
309        list_save_file = self.convert_to_list(
310            argument=save_file, length=len(list_pk))
311        list_save_path = self.convert_to_list(
312            argument=save_path, length=len(list_pk))
313        list_file_name = self.convert_to_list(
314            argument=file_name, length=len(list_pk))
315        list_if_exists = self.convert_to_list(
316            argument=if_exists, length=len(list_pk))
317        list_base_filter_skip = self.convert_to_list(
318            argument=base_filter_skip, length=len(list_pk),
319            force_replicate=True)
320
321        column_arg = {
322            'model_class': list_model_class,
323            'pk': list_pk,
324            'file_field': list_file_field,
325            'auth_header': list_auth_header,
326            'save_file': list_save_file,
327            'save_path': list_save_path,
328            'file_name': list_file_name,
329            'if_exists': list_if_exists,
330            'base_filter_skip': list_base_filter_skip}
331        function_args = self.transpose_args(dict_list=column_arg)
332        return self.parallel_call(
333            function=self.retrieve_file, function_args=function_args,
334            n_parallel=n_parallel)
335
336    def parallel_retrieve_streaming_file(self, model_class: str,
337                                         list_pk: list[int],
338                                         file_field: str | list[str],
339                                         file_name: str | list[str],
340                                         auth_header: dict | list[dict] = None,
341                                         save_path: str | list[str] = "./",
342                                         if_exists: str | list[str] = "fail",
343                                         base_filter_skip: list | list[list] = None, # NOQA
344                                         n_parallel: int | None = None
345                                         ) -> str:
346        """Retrieve a file from PumpWood using streaming to retrieve content.
347
348        This funcion uses file streaming to retrieve file content, it should be
349        prefered when dealing with large (bigger than 10Mb) files transfer.
350        Using this end-point the file is not loaded on backend memory content
351        is transfered by chucks that are read at the storage and transfered
352        to user.
353
354        It will necessarily save the content as a file, there is not the
355        possibility of retrieving the content directly from request.
356
357        Args:
358            model_class:
359                Class of the model to retrieve file.
360            list_pk (list):
361                Pk of the object associeted file.
362            file_field:
363                Field of the file to be downloaded.
364            auth_header:
365                Dictionary containing the auth header.
366            save_path:
367                Path of the directory to save file.
368            file_name:
369                Name of the file, if None it will have same name as
370                saved in PumpWood.
371            if_exists:
372                Values must be in {'fail', 'change_name', 'overwrite'}.
373                Set what to do if there is a file with same name.
374            auth_header:
375                Auth header to substitute the microservice original
376                at the request (user impersonation).
377            base_filter_skip (list):
378                List of base query filter to be skiped, it is necessary to
379                be superuser to skip base query filters.
380            n_parallel (int):
381                Number of parallel requests, if None will use the default
382                one.
383
384        Returns:
385            Returns the file path that recived the file content.
386
387        Raises:
388            PumpWoodForbidden:
389                'storage_object attribute not set for view, file operations
390                are disable'. This indicates that storage for this backend
391                was not configured, so it is not possible to make storage
392                operations,
393            PumpWoodForbidden:
394                'file_field must be set on self.file_fields dictionary'. This
395                indicates that the `file_field` parameter is not listed as
396                a file field on the backend.
397            PumpWoodObjectDoesNotExist:
398                'field [{}] not found or null at object'. This indicates that
399                the file field requested is not present on object fields.
400            PumpWoodObjectDoesNotExist:
401                'Object not found in storage [{}]'. This indicates that the
402                file associated with file_field is not avaiable at the
403                storage. This should not ocorrur, it might have a manual
404                update at the model_class table or manual removal/rename of
405                files on storage.
406        """
407        n_parallel = self.get_n_parallel(n_parallel=n_parallel)
408
409        # Convert arguments to list
410        list_model_class = self.convert_to_list(
411            argument=model_class, length=len(list_pk))
412        list_file_field = self.convert_to_list(
413            argument=file_field, length=len(list_pk))
414        list_file_name = self.convert_to_list(
415            argument=file_name, length=len(list_pk))
416        list_auth_header = self.convert_to_list(
417            argument=auth_header, length=len(list_pk))
418        list_save_path = self.convert_to_list(
419            argument=save_path, length=len(list_pk))
420        list_if_exists = self.convert_to_list(
421            argument=if_exists, length=len(list_pk))
422        list_base_filter_skip = self.convert_to_list(
423            argument=base_filter_skip, length=len(list_pk),
424            force_replicate=True)
425
426        column_arg = {
427            'model_class': list_model_class,
428            'pk': list_pk,
429            'file_field': list_file_field,
430            'file_name': list_file_name,
431            'auth_header': list_auth_header,
432            'save_path': list_save_path,
433            'if_exists': list_if_exists,
434            'base_filter_skip': list_base_filter_skip,
435        }
436        function_args = self.transpose_args(dict_list=column_arg)
437        return self.parallel_call(
438            function=self.retrieve_streaming_file, function_args=function_args,
439            n_parallel=n_parallel)