Merge commit from fork

* fix: remove Google App Engine urlfetch transport

* refactor: remove unused Requestor URL helpers

Author: Justintime50

CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## Next Release
+
+- Removes the legacy Google App Engine `urlfetch` transport; all requests now use `requests`
+
 ## v10.8.0 (2026-10-27)
 
 - Removes the deprecated, unusable `add_credit_card` function

README.md

@@ -140,14 +140,3 @@ Some tests may require an EasyPost user with a particular set of enabled feature
 - `USPS_CARRIER_ACCOUNT_ID` (eg: one-call buying a shipment for non-EasyPost employees)
 - `PARTNER_USER_PROD_API_KEY` (eg: creating a referral user)
 - `REFERRAL_CUSTOMER_PROD_API_KEY` (eg: adding a credit card to a referral user)
-
-#### Google Cloud SDK
-
-To run the test suite with the Google Cloud SDK (`urlfetch` instead of the `requests` library), you'll need the following:
-
-1. Install the appengine Python package to this virtual environment: `venv/bin/pip install appengine-python-standard`
-1. Install the Google Cloud SDK
-   - [Direct Download](https://cloud.google.com/sdk/docs/install)
-   - [Homebrew](https://formulae.brew.sh/cask/google-cloud-sdk)
-1. Point the `PYTHONPATH` environment variable to the path of the newly installed `google-cloud-sdk` directory. For Homebrew, this is `"$(brew --prefix)/share/google-cloud-sdk"`
-1. Run the test suite with the commands listed in this README

easypost/constant.py

@@ -14,7 +14,6 @@
 COMMUNICATION_ERROR = "Unexpected error communicating with EasyPost. If this problem persists please let us know at {}. Original error: {}"
 INVALID_DELIVER_ACCURACY_ERROR = "Invalid delivery_accuracy value, must be one of: {}"
 INVALID_PAYMENT_METHOD_ERROR = "The chosen payment method is not valid. Please try again."
-INVALID_REQUEST_LIB_ERROR = "Bug discovered: invalid request_lib: {}. Please report to {}."
 INVALID_REQUEST_METHOD_ERROR = "Bug discovered: invalid request method: {}. Please report to {}."
 INVALID_REQUEST_PARAMETERS_ERROR = "Only GET and DELETE requests support parameters."
 INVALID_REQUESTS_VERSION_ERROR = 'EasyPost requires an up to date requests library. Update requests via "pip install -U requests" or contact us at {}.'

easypost/easypost_client.py

@@ -96,36 +96,26 @@ def __init__(
         self._request_hook = RequestHook()
         self._response_hook = ResponseHook()
 
-        # use urlfetch as request_lib on google app engine, otherwise use requests
-        self._request_lib = None
         try:
-            from google.appengine.api import urlfetch  # type: ignore
-
-            self._request_lib = "urlfetch"
-            # use the GAE application-wide "deadline" (or its default)
-            timeout = urlfetch.get_default_fetch_deadline() or self.timeout
-        except ImportError:
-            try:
-                import requests
-
-                self._request_lib = "requests"
-                self._requests_session = requests.Session()
-                requests_http_adapter = requests.adapters.HTTPAdapter(max_retries=3)
-                self._requests_session.mount(
-                    prefix=self.api_base.split(f"/{API_VERSION}")[0],
-                    adapter=requests_http_adapter,
-                )
-            except Exception:
-                raise ImportError(INVALID_REQUESTS_VERSION_ERROR.format(SUPPORT_EMAIL))
+            import requests
+
+            self._requests_session = requests.Session()
+            requests_http_adapter = requests.adapters.HTTPAdapter(max_retries=3)
+            self._requests_session.mount(
+                prefix=self.api_base.split(f"/{API_VERSION}")[0],
+                adapter=requests_http_adapter,
+            )
+        except Exception:
+            raise ImportError(INVALID_REQUESTS_VERSION_ERROR.format(SUPPORT_EMAIL))
 
-            try:
-                requests_version = requests.__version__
-                major_version, _, _ = [int(i) for i in requests_version.split(".")]
-            except Exception:
+        try:
+            requests_version = requests.__version__
+            major_version, _, _ = [int(i) for i in requests_version.split(".")]
+        except Exception:
+            raise ImportError(INVALID_REQUESTS_VERSION_ERROR.format(SUPPORT_EMAIL))
+        else:
+            if major_version < 1:
                 raise ImportError(INVALID_REQUESTS_VERSION_ERROR.format(SUPPORT_EMAIL))
-            else:
-                if major_version < 1:
-                    raise ImportError(INVALID_REQUESTS_VERSION_ERROR.format(SUPPORT_EMAIL))
 
     def subscribe_to_request_hook(self, function):
         """Subscribe functions to run when a request occurs."""

easypost/requestor.py

@@ -1,24 +1,20 @@
 import datetime
 import json
 import platform
-import time
 import uuid
 from enum import Enum
 from json import JSONDecodeError
 from typing import (
     Any,
     Optional,
     Tuple,
-    Union,
 )
-from urllib.parse import urlencode
 
 import requests
 
 from easypost.constant import (
     API_VERSION,
     COMMUNICATION_ERROR,
-    INVALID_REQUEST_LIB_ERROR,
     INVALID_REQUEST_METHOD_ERROR,
     INVALID_REQUEST_PARAMETERS_ERROR,
     INVALID_RESPONSE_BODY_ERROR,
@@ -212,16 +208,9 @@ def request_raw(
             request_uuid=request_uuid,
         )
 
-        if self._client._request_lib == "urlfetch":
-            http_body, http_status, http_headers = self.urlfetch_request(
-                method=method, abs_url=abs_url, headers=headers, params=params
-            )
-        elif self._client._request_lib == "requests":
-            http_body, http_status, http_headers = self.requests_request(
-                method=method, abs_url=abs_url, headers=headers, params=params
-            )
-        else:
-            raise EasyPostError(INVALID_REQUEST_LIB_ERROR.format(self._client._request_lib, SUPPORT_EMAIL))
+        http_body, http_status, http_headers = self.requests_request(
+            method=method, abs_url=abs_url, headers=headers, params=params
+        )
 
         response_timestamp = datetime.datetime.now(datetime.timezone.utc)
         self._client._response_hook(
@@ -293,40 +282,6 @@ def requests_request(
 
         return http_body, http_status, http_headers
 
-    def urlfetch_request(
-        self,
-        method: RequestMethod,
-        abs_url: str,
-        headers: dict[str, Any],
-        params: dict[str, Any],
-    ) -> Tuple[str, int, dict[str, Any]]:
-        """Make a request by using the `urlfetch` library."""
-        fetch_args = {
-            "method": method.value,
-            "headers": headers,
-            "validate_certificate": False,
-            "deadline": self._client.timeout,
-        }
-
-        if method in [RequestMethod.GET, RequestMethod.DELETE]:
-            # GET/DELETE requests use query params
-            fetch_args["url"] = self.add_params_to_url(url=abs_url, params=params, method=method)
-        elif method in [RequestMethod.POST, RequestMethod.PUT]:
-            fetch_args["url"] = abs_url
-            # POST/PUT requests use body params
-            fetch_args["payload"] = json.dumps(params, default=self._utf8)
-        else:
-            raise EasyPostError(INVALID_REQUEST_METHOD_ERROR.format(method, SUPPORT_EMAIL))
-
-        try:
-            from google.appengine.api import urlfetch  # type: ignore
-
-            result = urlfetch.fetch(**fetch_args)  # type: ignore
-        except Exception as e:
-            raise HttpError(COMMUNICATION_ERROR.format(SUPPORT_EMAIL, e))
-
-        return result.content, result.status_code, result.headers
-
     def handle_api_error(self, http_status: int, http_body: str, response: dict[str, Any]) -> None:
         """Handles API errors returned from the EasyPost API."""
         try:
@@ -348,37 +303,3 @@ def handle_api_error(self, http_status: int, http_body: str, response: dict[str,
             http_status=http_status,
             http_body=http_body,
         )
-
-    def _utf8(self, value: Union[str, bytes]) -> str:
-        # Python3's str(bytestring) returns "b'bytestring'" so we use .decode instead
-        if isinstance(value, bytes):
-            return value.decode(encoding="utf-8")
-        return value
-
-    def encode_url_params(self, params: dict[str, Any], method: RequestMethod) -> Union[str, None]:
-        """Encode params for a URL."""
-        if method not in [RequestMethod.GET, RequestMethod.DELETE]:
-            raise EasyPostError(INVALID_REQUEST_PARAMETERS_ERROR)
-
-        converted_params = []
-
-        for key, value in sorted(params.items()):
-            if value is None:
-                continue  # Don't add Nones to the query
-            elif isinstance(value, datetime.datetime):
-                value = int(time.mktime(value.timetuple()))  # to UTC timestamp
-            converted_params.append((key, value))
-
-        return urlencode(query=converted_params)
-
-    def add_params_to_url(self, url: str, params: dict[str, Any], method: RequestMethod) -> str:
-        """Add params to the URL."""
-        if method not in [RequestMethod.GET, RequestMethod.DELETE]:
-            raise EasyPostError(INVALID_REQUEST_PARAMETERS_ERROR)
-
-        encoded_params = self.encode_url_params(params=params, method=method)
-
-        if encoded_params:
-            return "%s?%s" % (url, encoded_params)
-
-        return url

tests/conftest.py

@@ -21,27 +21,6 @@
 SCRUBBED_DICT: dict = {}
 
 
-def pytest_sessionstart(session):
-    """This is for local unit testing with google appengine, otherwise you get a
-    'No api proxy found for service "urlfetch"' response.
-    """
-    try:
-        from google.appengine.ext import testbed  # type: ignore
-
-        session.appengine_testbed = testbed.Testbed()  # type: ignore
-        session.appengine_testbed.activate()  # type: ignore
-        session.appengine_testbed.init_urlfetch_stub()  # type: ignore
-    except ImportError:
-        # if the import fails then we're not using the appengine sdk, so just
-        # keep going without initializing the testbed stub
-        pass
-
-
-def pytest_sessionfinish(session, exitstatus):
-    if hasattr(session, "appengine_testbed"):
-        session.appengine_testbed.deactivate()  # type: ignore
-
-
 @pytest.fixture(autouse=True)
 def check_expired_cassettes(expiration_days: int = 365, throw_error: bool = False):
     """Checks for expired cassettes and throws errors if they are too old and must be re-recorded."""