pangea-sdk 3.1.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

pangea/request.py

@@ -12,7 +12,7 @@ import pangea
 import pangea.exceptions as pe
 import requests
 from pangea.config import PangeaConfig
-from pangea.response import AcceptedResult, PangeaResponse, PangeaResponseResult, ResponseStatus, TransferMethod
+from pangea.response import PangeaResponse, PangeaResponseResult, ResponseStatus, TransferMethod
 from pangea.utils import default_encoder
 from requests.adapters import HTTPAdapter, Retry
 
@@ -203,12 +203,16 @@ class PangeaRequest(PangeaRequestBase):
         if self.config_id and data.get("config_id", None) is None:
             data["config_id"] = self.config_id
 
+        transfer_method = data.get("transfer_method", None)
+
         if (
             files is not None
             and type(data) is dict
-            and data.get("transfer_method", None) == TransferMethod.DIRECT.value
+            and (transfer_method == TransferMethod.DIRECT.value or transfer_method == TransferMethod.POST_URL.value)
         ):
-            requests_response = self._post_presigned_url(endpoint, result_class=result_class, data=data, files=files)
+            requests_response = self._full_post_presigned_url(
+                endpoint, result_class=result_class, data=data, files=files
+            )
         else:
             requests_response = self._http_post(
                 url, headers=self._headers(), data=data, files=files, multipart_post=True
@@ -220,13 +224,106 @@ class PangeaRequest(PangeaRequestBase):
 
         return self._check_response(pangea_response)
 
+    def get(self, path: str, result_class: Type[PangeaResponseResult], check_response: bool = True) -> PangeaResponse:
+        """Makes the GET call to a Pangea Service endpoint.
+
+        Args:
+            endpoint(str): The Pangea Service API endpoint.
+            path(str): Additional URL path
+
+        Returns:
+            PangeaResponse which contains the response in its entirety and
+               various properties to retrieve individual fields
+        """
+
+        url = self._url(path)
+        self.logger.debug(json.dumps({"service": self.service, "action": "get", "url": url}))
+        requests_response = self.session.get(url, headers=self._headers())
+        pangea_response = PangeaResponse(requests_response, result_class=result_class, json=requests_response.json())
+
+        self.logger.debug(
+            json.dumps(
+                {"service": self.service, "action": "get", "url": url, "response": pangea_response.json},
+                default=default_encoder,
+            )
+        )
+
+        if check_response is False:
+            return pangea_response
+
+        return self._check_response(pangea_response)
+
+    def poll_result_by_id(
+        self, request_id: str, result_class: Union[Type[PangeaResponseResult], dict], check_response: bool = True
+    ):
+        path = self._get_poll_path(request_id)
+        self.logger.debug(json.dumps({"service": self.service, "action": "poll_result_once", "url": path}))
+        return self.get(path, result_class, check_response=check_response)
+
+    def poll_result_once(self, response: PangeaResponse, check_response: bool = True):
+        request_id = response.request_id
+        if not request_id:
+            raise pe.PangeaException("Poll result error: response did not include a 'request_id'")
+
+        if response.status != ResponseStatus.ACCEPTED.value:
+            raise pe.PangeaException("Response already proccesed")
+
+        return self.poll_result_by_id(request_id, response.result_class, check_response=check_response)
+
+    def request_presigned_url(
+        self,
+        endpoint: str,
+        result_class: Type[PangeaResponseResult],
+        data: Union[str, Dict] = {},
+    ) -> PangeaResponse:
+        # Send request
+        try:
+            # This should return 202 (AcceptedRequestException)
+            resp = self.post(endpoint=endpoint, result_class=result_class, data=data, poll_result=False)
+            raise pe.PresignedURLException("Should return 202", resp)
+
+        except pe.AcceptedRequestException as e:
+            accepted_exception = e
+        except Exception as e:
+            raise e
+
+        # Receive 202 with accepted_status
+        return self._poll_presigned_url(accepted_exception.response)
+
+    def post_presigned_url(self, url: str, data: Dict, files: List[Tuple]):
+        # Send form request with file and upload_details as body
+        resp = self._http_post(url=url, data=data, files=files, multipart_post=False)
+        self.logger.debug(
+            json.dumps(
+                {"service": self.service, "action": "post presigned", "url": url, "response": resp.text},
+                default=default_encoder,
+            )
+        )
+
+        if resp.status_code < 200 or resp.status_code >= 300:
+            raise pe.PresignedUploadError(f"presigned POST failure: {resp.status_code}", resp.text)
+
+    def put_presigned_url(self, url: str, files: List[Tuple]):
+        # Send put request with file as body
+        resp = self._http_put(url=url, files=files)
+        self.logger.debug(
+            json.dumps(
+                {"service": self.service, "action": "put presigned", "url": url, "response": resp.text},
+                default=default_encoder,
+            )
+        )
+
+        if resp.status_code < 200 or resp.status_code >= 300:
+            raise pe.PresignedUploadError(f"presigned PUT failure: {resp.status_code}", resp.text)
+
+    # Start internal methods
     def _http_post(
         self,
         url: str,
         headers: Dict = {},
         data: Union[str, Dict] = {},
         files: Optional[List[Tuple]] = None,
-        multipart_post: bool = True,
+        multipart_post: bool = True,  # Multipart or form post
     ) -> requests.Response:
         self.logger.debug(
             json.dumps(
@@ -237,6 +334,17 @@ class PangeaRequest(PangeaRequestBase):
         data_send, files = self._http_post_process(data=data, files=files, multipart_post=multipart_post)
         return self.session.post(url, headers=headers, data=data_send, files=files)
 
+    def _http_put(
+        self,
+        url: str,
+        files: List[Tuple],
+        headers: Dict = {},
+    ) -> requests.Response:
+        self.logger.debug(
+            json.dumps({"service": self.service, "action": "http_put", "url": url}, default=default_encoder)
+        )
+        return self.session.put(url, headers=headers, files=files)
+
     def _http_post_process(
         self, data: Union[str, Dict] = {}, files: Optional[List[Tuple]] = None, multipart_post: bool = True
     ):
@@ -263,7 +371,7 @@ class PangeaRequest(PangeaRequestBase):
 
         return data, files
 
-    def _post_presigned_url(
+    def _full_post_presigned_url(
         self,
         endpoint: str,
         result_class: Type[PangeaResponseResult],
@@ -273,35 +381,12 @@ class PangeaRequest(PangeaRequestBase):
         if len(files) == 0:
             raise AttributeError("files attribute should have at least 1 file")
 
-        # Send request
-        try:
-            # This should return 202 (AcceptedRequestException)
-            resp = self.post(endpoint=endpoint, result_class=result_class, data=data, poll_result=False)
-            raise pe.PresignedURLException("Should return 202", resp)
-
-        except pe.AcceptedRequestException as e:
-            accepted_exception = e
-        except Exception as e:
-            raise e
-
-        # Receive 202 with accepted_status
-        result = self._poll_presigned_url(accepted_exception)
-        data_to_presigned = result.accepted_status.upload_details
-        presigned_url = result.accepted_status.upload_url
-
-        # Send multipart request with file and upload_details as body
-        resp = self._http_post(url=presigned_url, data=data_to_presigned, files=files, multipart_post=False)
-        self.logger.debug(
-            json.dumps(
-                {"service": self.service, "action": "post presigned", "url": presigned_url, "response": resp.text},
-                default=default_encoder,
-            )
-        )
-
-        if resp.status_code < 200 or resp.status_code >= 300:
-            raise pe.PresignedUploadError(f"presigned POST failure: {resp.status_code}", resp.text)
+        response = self.request_presigned_url(endpoint=endpoint, result_class=result_class, data=data)
+        data_to_presigned = response.accepted_result.accepted_status.upload_details
+        presigned_url = response.accepted_result.accepted_status.upload_url
 
-        return accepted_exception.response.raw_response
+        self.post_presigned_url(url=presigned_url, data=data_to_presigned, files=files)
+        return response.raw_response
 
     def _handle_queued_result(self, response: PangeaResponse) -> PangeaResponse:
         if self._queued_retry_enabled and response.raw_response.status_code == 202:
@@ -315,52 +400,6 @@ class PangeaRequest(PangeaRequestBase):
 
         return response
 
-    def get(self, path: str, result_class: Type[PangeaResponseResult], check_response: bool = True) -> PangeaResponse:
-        """Makes the GET call to a Pangea Service endpoint.
-
-        Args:
-            endpoint(str): The Pangea Service API endpoint.
-            path(str): Additional URL path
-
-        Returns:
-            PangeaResponse which contains the response in its entirety and
-               various properties to retrieve individual fields
-        """
-
-        url = self._url(path)
-        self.logger.debug(json.dumps({"service": self.service, "action": "get", "url": url}))
-        requests_response = self.session.get(url, headers=self._headers())
-        pangea_response = PangeaResponse(requests_response, result_class=result_class, json=requests_response.json())
-
-        self.logger.debug(
-            json.dumps(
-                {"service": self.service, "action": "get", "url": url, "response": pangea_response.json},
-                default=default_encoder,
-            )
-        )
-
-        if check_response is False:
-            return pangea_response
-
-        return self._check_response(pangea_response)
-
-    def poll_result_by_id(
-        self, request_id: str, result_class: Union[Type[PangeaResponseResult], dict], check_response: bool = True
-    ):
-        path = self._get_poll_path(request_id)
-        self.logger.debug(json.dumps({"service": self.service, "action": "poll_result_once", "url": path}))
-        return self.get(path, result_class, check_response=check_response)
-
-    def poll_result_once(self, response: PangeaResponse, check_response: bool = True):
-        request_id = response.request_id
-        if not request_id:
-            raise pe.PangeaException("Poll result error: response did not include a 'request_id'")
-
-        if response.status != ResponseStatus.ACCEPTED.value:
-            raise pe.PangeaException("Response already proccesed")
-
-        return self.poll_result_by_id(request_id, response.result_class, check_response=check_response)
-
     def _poll_result_retry(self, response: PangeaResponse) -> PangeaResponse:
         retry_count = 1
         start = time.time()
@@ -373,26 +412,26 @@ class PangeaRequest(PangeaRequestBase):
         self.logger.debug(json.dumps({"service": self.service, "action": "poll_result_retry", "step": "exit"}))
         return self._check_response(response)
 
-    def _poll_presigned_url(self, initial_exc: pe.AcceptedRequestException) -> AcceptedResult:
-        if type(initial_exc) is not pe.AcceptedRequestException:
-            raise AttributeError("Exception should be of type AcceptedRequestException")
+    def _poll_presigned_url(self, response: PangeaResponse) -> PangeaResponse:
+        if response.http_status != 202:
+            raise AttributeError("Response should be 202")
 
-        if initial_exc.accepted_result.accepted_status.upload_url:
-            return initial_exc.accepted_result
+        if response.accepted_result.accepted_status.upload_url:
+            return response
 
         self.logger.debug(json.dumps({"service": self.service, "action": "poll_presigned_url", "step": "start"}))
         retry_count = 1
         start = time.time()
-        loop_exc = initial_exc
+        loop_resp = response
 
         while (
-            loop_exc.accepted_result is not None
-            and not loop_exc.accepted_result.accepted_status.upload_url
+            loop_resp.accepted_result is not None
+            and not loop_resp.accepted_result.accepted_status.upload_url
             and not self._reach_timeout(start)
         ):
             time.sleep(self._get_delay(retry_count, start))
             try:
-                self.poll_result_once(initial_exc.response, check_response=False)
+                self.poll_result_once(loop_resp, check_response=False)
                 msg = "Polling presigned url return 200 instead of 202"
                 self.logger.debug(
                     json.dumps(
@@ -402,6 +441,7 @@ class PangeaRequest(PangeaRequestBase):
                 raise pe.PangeaException(msg)
             except pe.AcceptedRequestException as e:
                 retry_count += 1
+                loop_resp = e.response
                 loop_exc = e
             except Exception as e:
                 self.logger.debug(
@@ -409,12 +449,12 @@ class PangeaRequest(PangeaRequestBase):
                         {"service": self.service, "action": "poll_presigned_url", "step": "exit", "cause": {str(e)}}
                     )
                 )
-                raise pe.PresignedURLException("Failed to pull Presigned URL", loop_exc.response, e)
+                raise pe.PresignedURLException("Failed to pull Presigned URL", loop_resp, e)
 
         self.logger.debug(json.dumps({"service": self.service, "action": "poll_presigned_url", "step": "exit"}))
 
-        if loop_exc.accepted_result is not None and not loop_exc.accepted_result.accepted_status.upload_url:
-            return loop_exc.accepted_result
+        if loop_resp.accepted_result is not None and not loop_resp.accepted_result.accepted_status.upload_url:
+            return loop_resp
         else:
             raise loop_exc
 

pangea/response.py

@@ -13,8 +13,11 @@ T = TypeVar("T")
 
 
 class TransferMethod(str, enum.Enum):
-    DIRECT = "direct"
+    DIRECT = "post-url"  # deprecated, use POST_URL instead
     MULTIPART = "multipart"
+    POST_URL = "post-url"
+    PUT_URL = "put-url"
+    # URL = "url"
 
     def __str__(self):
         return str(self.value)
@@ -76,7 +79,7 @@ class AcceptedStatus(APIResponseModel):
 
 
 class AcceptedResult(PangeaResponseResult):
-    accepted_status: AcceptedStatus
+    accepted_status: Optional[AcceptedStatus] = None
 
 
 class PangeaError(PangeaResponseResult):
@@ -144,8 +147,11 @@ class PangeaResponse(Generic[T], ResponseHeader):
             if self.raw_result is not None and issubclass(self.result_class, PangeaResponseResult) and self.success
             else None
         )
-        if not self.success and self.http_status != 202:
-            self.pangea_error = PangeaError(**self.raw_result) if self.raw_result is not None else None
+        if not self.success:
+            if self.http_status == 202:
+                self.accepted_result = AcceptedResult(**self.raw_result) if self.raw_result is not None else None
+            else:
+                self.pangea_error = PangeaError(**self.raw_result) if self.raw_result is not None else None
 
     @property
     def success(self) -> bool: