nova.api

10class ApiResponse(BaseModel, Generic[T]):
11    """
12    API response object
13    """
14
15    status_code: StrictInt = Field(description="HTTP status code")
16    headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
17    data: T = Field(description="Deserialized data given the data type")
18    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
19
20    model_config = {
21        "arbitrary_types_allowed": True
22    }

 45class ApiClient:
 46    """Generic API client for OpenAPI client library builds.
 47
 48    OpenAPI generic API client. This client handles the client-
 49    server communication, and is invariant across implementations. Specifics of
 50    the methods and models for each application are generated from the OpenAPI
 51    templates.
 52
 53    :param configuration: .Configuration object for this client
 54    :param header_name: a header to pass when making calls to the API.
 55    :param header_value: a header value to pass when making calls to
 56        the API.
 57    :param cookie: a cookie to include in the header when making calls
 58        to the API
 59    """
 60
 61    PRIMITIVE_TYPES = (float, bool, bytes, str, int)
 62    NATIVE_TYPES_MAPPING = {
 63        'int': int,
 64        'long': int, # TODO remove as only py3 is supported?
 65        'float': float,
 66        'str': str,
 67        'bool': bool,
 68        'date': datetime.date,
 69        'datetime': datetime.datetime,
 70        'object': object,
 71    }
 72    _pool = None
 73
 74    def __init__(
 75        self,
 76        configuration=None,
 77        header_name=None,
 78        header_value=None,
 79        cookie=None
 80    ) -> None:
 81        # use default configuration if none is provided
 82        if configuration is None:
 83            configuration = Configuration.get_default()
 84        self.configuration = configuration
 85
 86        self.rest_client = rest.RESTClientObject(configuration)
 87        self.default_headers = {}
 88        if header_name is not None:
 89            self.default_headers[header_name] = header_value
 90        self.cookie = cookie
 91        # Set default User-Agent.
 92        self.user_agent = 'OpenAPI-Generator/25.1.0/python'
 93        self.client_side_validation = configuration.client_side_validation
 94
 95    async def __aenter__(self):
 96        return self
 97
 98    async def __aexit__(self, exc_type, exc_value, traceback):
 99        await self.close()
100
101    async def close(self):
102        await self.rest_client.close()
103
104    @property
105    def user_agent(self):
106        """User agent for this API client"""
107        return self.default_headers['User-Agent']
108
109    @user_agent.setter
110    def user_agent(self, value):
111        self.default_headers['User-Agent'] = value
112
113    def set_default_header(self, header_name, header_value):
114        self.default_headers[header_name] = header_value
115
116
117    _default = None
118
119    @classmethod
120    def get_default(cls):
121        """Return new instance of ApiClient.
122
123        This method returns newly created, based on default constructor,
124        object of ApiClient class or returns a copy of default
125        ApiClient.
126
127        :return: The ApiClient object.
128        """
129        if cls._default is None:
130            cls._default = ApiClient()
131        return cls._default
132
133    @classmethod
134    def set_default(cls, default):
135        """Set default instance of ApiClient.
136
137        It stores default ApiClient.
138
139        :param default: object of ApiClient.
140        """
141        cls._default = default
142
143    def param_serialize(
144        self,
145        method,
146        resource_path,
147        path_params=None,
148        query_params=None,
149        header_params=None,
150        body=None,
151        post_params=None,
152        files=None, auth_settings=None,
153        collection_formats=None,
154        _host=None,
155        _request_auth=None
156    ) -> RequestSerialized:
157
158        """Builds the HTTP request params needed by the request.
159        :param method: Method to call.
160        :param resource_path: Path to method endpoint.
161        :param path_params: Path parameters in the url.
162        :param query_params: Query parameters in the url.
163        :param header_params: Header parameters to be
164            placed in the request header.
165        :param body: Request body.
166        :param post_params dict: Request post form parameters,
167            for `application/x-www-form-urlencoded`, `multipart/form-data`.
168        :param auth_settings list: Auth Settings names for the request.
169        :param files dict: key -> filename, value -> filepath,
170            for `multipart/form-data`.
171        :param collection_formats: dict of collection formats for path, query,
172            header, and post parameters.
173        :param _request_auth: set to override the auth_settings for an a single
174                              request; this effectively ignores the authentication
175                              in the spec for a single request.
176        :return: tuple of form (path, http_method, query_params, header_params,
177            body, post_params, files)
178        """
179
180        config = self.configuration
181
182        # header parameters
183        header_params = header_params or {}
184        header_params.update(self.default_headers)
185        if self.cookie:
186            header_params['Cookie'] = self.cookie
187        if header_params:
188            header_params = self.sanitize_for_serialization(header_params)
189            header_params = dict(
190                self.parameters_to_tuples(header_params,collection_formats)
191            )
192
193        # path parameters
194        if path_params:
195            path_params = self.sanitize_for_serialization(path_params)
196            path_params = self.parameters_to_tuples(
197                path_params,
198                collection_formats
199            )
200            for k, v in path_params:
201                # specified safe chars, encode everything
202                resource_path = resource_path.replace(
203                    '{%s}' % k,
204                    quote(str(v), safe=config.safe_chars_for_path_param)
205                )
206
207        # post parameters
208        if post_params or files:
209            post_params = post_params if post_params else []
210            post_params = self.sanitize_for_serialization(post_params)
211            post_params = self.parameters_to_tuples(
212                post_params,
213                collection_formats
214            )
215            if files:
216                post_params.extend(self.files_parameters(files))
217
218        # auth setting
219        self.update_params_for_auth(
220            header_params,
221            query_params,
222            auth_settings,
223            resource_path,
224            method,
225            body,
226            request_auth=_request_auth
227        )
228
229        # body
230        if body:
231            body = self.sanitize_for_serialization(body)
232
233        # request url
234        if _host is None:
235            url = self.configuration.host + resource_path
236        else:
237            # use server/host defined in path or operation instead
238            url = _host + resource_path
239
240        # query parameters
241        if query_params:
242            query_params = self.sanitize_for_serialization(query_params)
243            url_query = self.parameters_to_url_query(
244                query_params,
245                collection_formats
246            )
247            url += "?" + url_query
248
249        return method, url, header_params, body, post_params
250
251
252    async def call_api(
253        self,
254        method,
255        url,
256        header_params=None,
257        body=None,
258        post_params=None,
259        _request_timeout=None
260    ) -> rest.RESTResponse:
261        """Makes the HTTP request (synchronous)
262        :param method: Method to call.
263        :param url: Path to method endpoint.
264        :param header_params: Header parameters to be
265            placed in the request header.
266        :param body: Request body.
267        :param post_params dict: Request post form parameters,
268            for `application/x-www-form-urlencoded`, `multipart/form-data`.
269        :param _request_timeout: timeout setting for this request.
270        :return: RESTResponse
271        """
272
273        try:
274            # perform request and return response
275            response_data = await self.rest_client.request(
276                method, url,
277                headers=header_params,
278                body=body, post_params=post_params,
279                _request_timeout=_request_timeout
280            )
281
282        except ApiException as e:
283            raise e
284
285        return response_data
286
287    def response_deserialize(
288        self,
289        response_data: rest.RESTResponse,
290        response_types_map: Optional[Dict[str, ApiResponseT]]=None
291    ) -> ApiResponse[ApiResponseT]:
292        """Deserializes response into an object.
293        :param response_data: RESTResponse object to be deserialized.
294        :param response_types_map: dict of response types.
295        :return: ApiResponse
296        """
297
298        msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
299        assert response_data.data is not None, msg
300
301        response_type = response_types_map.get(str(response_data.status), None)
302        if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
303            # if not found, look for '1XX', '2XX', etc.
304            response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
305
306        # deserialize response data
307        response_text = None
308        return_data = None
309        try:
310            if response_type == "bytearray":
311                return_data = response_data.data
312            elif response_type == "file":
313                return_data = self.__deserialize_file(response_data)
314            elif response_type is not None:
315                match = None
316                content_type = response_data.getheader('content-type')
317                if content_type is not None:
318                    match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
319                encoding = match.group(1) if match else "utf-8"
320                response_text = response_data.data.decode(encoding)
321                if response_type in ["bytearray", "str"]:
322                    return_data = self.__deserialize_primitive(response_text, response_type)
323                else:
324                    return_data = self.deserialize(response_text, response_type)
325        finally:
326            if not 200 <= response_data.status <= 299:
327                raise ApiException.from_response(
328                    http_resp=response_data,
329                    body=response_text,
330                    data=return_data,
331                )
332
333        return ApiResponse(
334            status_code = response_data.status,
335            data = return_data,
336            headers = response_data.getheaders(),
337            raw_data = response_data.data
338        )
339
340    def sanitize_for_serialization(self, obj):
341        """Builds a JSON POST object.
342
343        If obj is None, return None.
344        If obj is SecretStr, return obj.get_secret_value()
345        If obj is str, int, long, float, bool, return directly.
346        If obj is datetime.datetime, datetime.date
347            convert to string in iso8601 format.
348        If obj is list, sanitize each element in the list.
349        If obj is dict, return the dict.
350        If obj is OpenAPI model, return the properties dict.
351
352        :param obj: The data to serialize.
353        :return: The serialized form of data.
354        """
355        if obj is None:
356            return None
357        elif isinstance(obj, Enum):
358            return obj.value
359        elif isinstance(obj, SecretStr):
360            return obj.get_secret_value()
361        elif isinstance(obj, self.PRIMITIVE_TYPES):
362            return obj
363        elif isinstance(obj, list):
364            return [
365                self.sanitize_for_serialization(sub_obj) for sub_obj in obj
366            ]
367        elif isinstance(obj, tuple):
368            return tuple(
369                self.sanitize_for_serialization(sub_obj) for sub_obj in obj
370            )
371        elif isinstance(obj, (datetime.datetime, datetime.date)):
372            return obj.isoformat()
373
374        elif isinstance(obj, dict):
375            obj_dict = obj
376        else:
377            # Convert model obj to dict except
378            # attributes `openapi_types`, `attribute_map`
379            # and attributes which value is not None.
380            # Convert attribute name to json key in
381            # model definition for request.
382            if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
383                obj_dict = obj.to_dict()
384            else:
385                obj_dict = obj.__dict__
386
387        return {
388            key: self.sanitize_for_serialization(val)
389            for key, val in obj_dict.items()
390        }
391
392    def deserialize(self, response_text, response_type):
393        """Deserializes response into an object.
394
395        :param response: RESTResponse object to be deserialized.
396        :param response_type: class literal for
397            deserialized object, or string of class name.
398
399        :return: deserialized object.
400        """
401
402        # fetch data from response object
403        try:
404            data = json.loads(response_text)
405        except ValueError:
406            data = response_text
407
408        return self.__deserialize(data, response_type)
409
410    def __deserialize(self, data, klass):
411        """Deserializes dict, list, str into an object.
412
413        :param data: dict, list or str.
414        :param klass: class literal, or string of class name.
415
416        :return: object.
417        """
418        if data is None:
419            return None
420
421        if isinstance(klass, str):
422            if klass.startswith('List['):
423                m = re.match(r'List\[(.*)]', klass)
424                assert m is not None, "Malformed List type definition"
425                sub_kls = m.group(1)
426                return [self.__deserialize(sub_data, sub_kls)
427                        for sub_data in data]
428
429            if klass.startswith('Dict['):
430                m = re.match(r'Dict\[([^,]*), (.*)]', klass)
431                assert m is not None, "Malformed Dict type definition"
432                sub_kls = m.group(2)
433                return {k: self.__deserialize(v, sub_kls)
434                        for k, v in data.items()}
435
436            # convert str to class
437            if klass in self.NATIVE_TYPES_MAPPING:
438                klass = self.NATIVE_TYPES_MAPPING[klass]
439            else:
440                klass = getattr(wandelbots_api_client.models, klass)
441
442        if klass in self.PRIMITIVE_TYPES:
443            return self.__deserialize_primitive(data, klass)
444        elif klass == object:
445            return self.__deserialize_object(data)
446        elif klass == datetime.date:
447            return self.__deserialize_date(data)
448        elif klass == datetime.datetime:
449            return self.__deserialize_datetime(data)
450        elif issubclass(klass, Enum):
451            return self.__deserialize_enum(data, klass)
452        else:
453            return self.__deserialize_model(data, klass)
454
455    def parameters_to_tuples(self, params, collection_formats):
456        """Get parameters as list of tuples, formatting collections.
457
458        :param params: Parameters as dict or list of two-tuples
459        :param dict collection_formats: Parameter collection formats
460        :return: Parameters as list of tuples, collections formatted
461        """
462        new_params: List[Tuple[str, str]] = []
463        if collection_formats is None:
464            collection_formats = {}
465        for k, v in params.items() if isinstance(params, dict) else params:
466            if k in collection_formats:
467                collection_format = collection_formats[k]
468                if collection_format == 'multi':
469                    new_params.extend((k, value) for value in v)
470                else:
471                    if collection_format == 'ssv':
472                        delimiter = ' '
473                    elif collection_format == 'tsv':
474                        delimiter = '\t'
475                    elif collection_format == 'pipes':
476                        delimiter = '|'
477                    else:  # csv is the default
478                        delimiter = ','
479                    new_params.append(
480                        (k, delimiter.join(str(value) for value in v)))
481            else:
482                new_params.append((k, v))
483        return new_params
484
485    def parameters_to_url_query(self, params, collection_formats):
486        """Get parameters as list of tuples, formatting collections.
487
488        :param params: Parameters as dict or list of two-tuples
489        :param dict collection_formats: Parameter collection formats
490        :return: URL query string (e.g. a=Hello%20World&b=123)
491        """
492        new_params: List[Tuple[str, str]] = []
493        if collection_formats is None:
494            collection_formats = {}
495        for k, v in params.items() if isinstance(params, dict) else params:
496            if isinstance(v, bool):
497                v = str(v).lower()
498            if isinstance(v, (int, float)):
499                v = str(v)
500            if isinstance(v, dict):
501                v = json.dumps(v)
502
503            if k in collection_formats:
504                collection_format = collection_formats[k]
505                if collection_format == 'multi':
506                    new_params.extend((k, str(value)) for value in v)
507                else:
508                    if collection_format == 'ssv':
509                        delimiter = ' '
510                    elif collection_format == 'tsv':
511                        delimiter = '\t'
512                    elif collection_format == 'pipes':
513                        delimiter = '|'
514                    else:  # csv is the default
515                        delimiter = ','
516                    new_params.append(
517                        (k, delimiter.join(quote(str(value)) for value in v))
518                    )
519            else:
520                new_params.append((k, quote(str(v))))
521
522        return "&".join(["=".join(map(str, item)) for item in new_params])
523
524    def files_parameters(self, files: Dict[str, Union[str, bytes]]):
525        """Builds form parameters.
526
527        :param files: File parameters.
528        :return: Form parameters with files.
529        """
530        params = []
531        for k, v in files.items():
532            if isinstance(v, str):
533                with open(v, 'rb') as f:
534                    filename = os.path.basename(f.name)
535                    filedata = f.read()
536            elif isinstance(v, bytes):
537                filename = k
538                filedata = v
539            else:
540                raise ValueError("Unsupported file value")
541            mimetype = (
542                mimetypes.guess_type(filename)[0]
543                or 'application/octet-stream'
544            )
545            params.append(
546                tuple([k, tuple([filename, filedata, mimetype])])
547            )
548        return params
549
550    def select_header_accept(self, accepts: List[str]) -> Optional[str]:
551        """Returns `Accept` based on an array of accepts provided.
552
553        :param accepts: List of headers.
554        :return: Accept (e.g. application/json).
555        """
556        if not accepts:
557            return None
558
559        for accept in accepts:
560            if re.search('json', accept, re.IGNORECASE):
561                return accept
562
563        return accepts[0]
564
565    def select_header_content_type(self, content_types):
566        """Returns `Content-Type` based on an array of content_types provided.
567
568        :param content_types: List of content-types.
569        :return: Content-Type (e.g. application/json).
570        """
571        if not content_types:
572            return None
573
574        for content_type in content_types:
575            if re.search('json', content_type, re.IGNORECASE):
576                return content_type
577
578        return content_types[0]
579
580    def update_params_for_auth(
581        self,
582        headers,
583        queries,
584        auth_settings,
585        resource_path,
586        method,
587        body,
588        request_auth=None
589    ) -> None:
590        """Updates header and query params based on authentication setting.
591
592        :param headers: Header parameters dict to be updated.
593        :param queries: Query parameters tuple list to be updated.
594        :param auth_settings: Authentication setting identifiers list.
595        :resource_path: A string representation of the HTTP request resource path.
596        :method: A string representation of the HTTP request method.
597        :body: A object representing the body of the HTTP request.
598        The object type is the return value of sanitize_for_serialization().
599        :param request_auth: if set, the provided settings will
600                             override the token in the configuration.
601        """
602        if not auth_settings:
603            return
604
605        if request_auth:
606            self._apply_auth_params(
607                headers,
608                queries,
609                resource_path,
610                method,
611                body,
612                request_auth
613            )
614        else:
615            for auth in auth_settings:
616                auth_setting = self.configuration.auth_settings().get(auth)
617                if auth_setting:
618                    self._apply_auth_params(
619                        headers,
620                        queries,
621                        resource_path,
622                        method,
623                        body,
624                        auth_setting
625                    )
626
627    def _apply_auth_params(
628        self,
629        headers,
630        queries,
631        resource_path,
632        method,
633        body,
634        auth_setting
635    ) -> None:
636        """Updates the request parameters based on a single auth_setting
637
638        :param headers: Header parameters dict to be updated.
639        :param queries: Query parameters tuple list to be updated.
640        :resource_path: A string representation of the HTTP request resource path.
641        :method: A string representation of the HTTP request method.
642        :body: A object representing the body of the HTTP request.
643        The object type is the return value of sanitize_for_serialization().
644        :param auth_setting: auth settings for the endpoint
645        """
646        if auth_setting['in'] == 'cookie':
647            headers['Cookie'] = auth_setting['value']
648        elif auth_setting['in'] == 'header':
649            if auth_setting['type'] != 'http-signature':
650                headers[auth_setting['key']] = auth_setting['value']
651        elif auth_setting['in'] == 'query':
652            queries.append((auth_setting['key'], auth_setting['value']))
653        else:
654            raise ApiValueError(
655                'Authentication token must be in `query` or `header`'
656            )
657
658    def __deserialize_file(self, response):
659        """Deserializes body to file
660
661        Saves response body into a file in a temporary folder,
662        using the filename from the `Content-Disposition` header if provided.
663
664        handle file downloading
665        save response body into a tmp file and return the instance
666
667        :param response:  RESTResponse.
668        :return: file path.
669        """
670        fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
671        os.close(fd)
672        os.remove(path)
673
674        content_disposition = response.getheader("Content-Disposition")
675        if content_disposition:
676            m = re.search(
677                r'filename=[\'"]?([^\'"\s]+)[\'"]?',
678                content_disposition
679            )
680            assert m is not None, "Unexpected 'content-disposition' header value"
681            filename = m.group(1)
682            path = os.path.join(os.path.dirname(path), filename)
683
684        with open(path, "wb") as f:
685            f.write(response.data)
686
687        return path
688
689    def __deserialize_primitive(self, data, klass):
690        """Deserializes string to primitive type.
691
692        :param data: str.
693        :param klass: class literal.
694
695        :return: int, long, float, str, bool.
696        """
697        try:
698            return klass(data)
699        except UnicodeEncodeError:
700            return str(data)
701        except TypeError:
702            return data
703
704    def __deserialize_object(self, value):
705        """Return an original value.
706
707        :return: object.
708        """
709        return value
710
711    def __deserialize_date(self, string):
712        """Deserializes string to date.
713
714        :param string: str.
715        :return: date.
716        """
717        try:
718            return parse(string).date()
719        except ImportError:
720            return string
721        except ValueError:
722            raise rest.ApiException(
723                status=0,
724                reason="Failed to parse `{0}` as date object".format(string)
725            )
726
727    def __deserialize_datetime(self, string):
728        """Deserializes string to datetime.
729
730        The string should be in iso8601 datetime format.
731
732        :param string: str.
733        :return: datetime.
734        """
735        try:
736            return parse(string)
737        except ImportError:
738            return string
739        except ValueError:
740            raise rest.ApiException(
741                status=0,
742                reason=(
743                    "Failed to parse `{0}` as datetime object"
744                    .format(string)
745                )
746            )
747
748    def __deserialize_enum(self, data, klass):
749        """Deserializes primitive type to enum.
750
751        :param data: primitive type.
752        :param klass: class literal.
753        :return: enum value.
754        """
755        try:
756            return klass(data)
757        except ValueError:
758            raise rest.ApiException(
759                status=0,
760                reason=(
761                    "Failed to parse `{0}` as `{1}`"
762                    .format(data, klass)
763                )
764            )
765
766    def __deserialize_model(self, data, klass):
767        """Deserializes list or dict to model.
768
769        :param data: dict, list.
770        :param klass: class literal.
771        :return: model object.
772        """
773
774        return klass.from_dict(data)