bookalimo 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

bookalimo/services/reservations.py

@@ -1,13 +1,9 @@
 """Reservations service for listing, getting, editing, and booking reservations."""
 
-from typing import Any, Optional
-
-from ..exceptions import BookalimoRequestError
-from ..schemas.booking import (
+from ..schemas import (
     BookRequest,
     BookResponse,
-    CreditCard,
-    EditableReservationRequest,
+    EditReservationRequest,
     EditReservationResponse,
     GetReservationRequest,
     GetReservationResponse,
@@ -53,73 +49,30 @@ class AsyncReservationsService:
             "/booking/reservation/get/", request, GetReservationResponse
         )
 
-    async def edit(
-        self, confirmation: str, *, is_cancel: bool = False, **changes: Any
-    ) -> EditReservationResponse:
+    async def edit(self, request: EditReservationRequest) -> EditReservationResponse:
         """
         Edit or cancel a reservation.
 
         Args:
-            confirmation: Confirmation number
-            is_cancel: True to cancel the reservation
-            **changes: Fields to change (rate_type, pickup_date, pickup_time,
-                      stops, passengers, luggage, pets, car_seats, boosters,
-                      infants, other)
+            request: Complete edit request with confirmation and fields to change
 
         Returns:
             EditReservationResponse
         """
-        request_data = {
-            "confirmation": confirmation,
-            "is_cancel_request": is_cancel,
-        }
-
-        # Add changes if not canceling
-        if not is_cancel:
-            for key, value in changes.items():
-                if value is not None:
-                    request_data[key] = value
-
-        request = EditableReservationRequest.model_validate(request_data)
         return await self._transport.post(
             "/booking/edit/", request, EditReservationResponse
         )
 
-    async def book(
-        self,
-        token: str,
-        *,
-        method: Optional[str] = None,
-        credit_card: Optional[CreditCard] = None,
-        promo: Optional[str] = None,
-    ) -> BookResponse:
+    async def book(self, request: BookRequest) -> BookResponse:
         """
         Book a reservation.
 
         Args:
-            token: Session token from pricing.quote() or pricing.update_details()
-            method: 'charge' for charge accounts, None for credit card
-            credit_card: Credit card information (required if method is not 'charge')
-            promo: Optional promo code
+            request: Complete booking request with token and payment details
 
         Returns:
             BookResponse with reservation_id
         """
-        request_data: dict[str, Any] = {"token": token}
-
-        if promo:
-            request_data["promo"] = promo
-
-        if method == "charge":
-            request_data["method"] = "charge"
-        elif credit_card:
-            request_data["credit_card"] = credit_card
-        else:
-            raise BookalimoRequestError(
-                "Either method='charge' or credit_card must be provided"
-            )
-
-        request = BookRequest(**request_data)
         return await self._transport.post("/booking/book/", request, BookResponse)
 
 
@@ -159,69 +112,26 @@ class ReservationsService:
             "/booking/reservation/get/", request, GetReservationResponse
         )
 
-    def edit(
-        self, confirmation: str, *, is_cancel: bool = False, **changes: Any
-    ) -> EditReservationResponse:
+    def edit(self, request: EditReservationRequest) -> EditReservationResponse:
         """
         Edit or cancel a reservation.
 
         Args:
-            confirmation: Confirmation number
-            is_cancel: True to cancel the reservation
-            **changes: Fields to change (rate_type, pickup_date, pickup_time,
-                      stops, passengers, luggage, pets, car_seats, boosters,
-                      infants, other)
+            request: Complete edit request with confirmation and fields to change
 
         Returns:
             EditReservationResponse
         """
-        request_data = {
-            "confirmation": confirmation,
-            "is_cancel_request": is_cancel,
-        }
-
-        # Add changes if not canceling
-        if not is_cancel:
-            for key, value in changes.items():
-                if value is not None:
-                    request_data[key] = value
-
-        request = EditableReservationRequest.model_validate(request_data)
         return self._transport.post("/booking/edit/", request, EditReservationResponse)
 
-    def book(
-        self,
-        token: str,
-        *,
-        method: Optional[str] = None,
-        credit_card: Optional[CreditCard] = None,
-        promo: Optional[str] = None,
-    ) -> BookResponse:
+    def book(self, request: BookRequest) -> BookResponse:
         """
         Book a reservation.
 
         Args:
-            token: Session token from pricing.quote() or pricing.update_details()
-            method: 'charge' for charge accounts, None for credit card
-            credit_card: Credit card information (required if method is not 'charge')
-            promo: Optional promo code
+            request: Complete booking request with token and payment details
 
         Returns:
             BookResponse with reservation_id
         """
-        request_data: dict[str, Any] = {"token": token}
-
-        if promo:
-            request_data["promo"] = promo
-
-        if method == "charge":
-            request_data["method"] = "charge"
-        elif credit_card:
-            request_data["credit_card"] = credit_card
-        else:
-            raise BookalimoRequestError(
-                "Either method='charge' or credit_card must be provided"
-            )
-
-        request = BookRequest.model_validate(request_data)
         return self._transport.post("/booking/book/", request, BookResponse)

bookalimo/transport/auth.py

@@ -3,10 +3,10 @@
 import hashlib
 from typing import Any, Optional
 
-from ..schemas.base import ApiModel
+from ..schemas.base import RequestModel
 
 
-class Credentials(ApiModel):
+class Credentials(RequestModel):
     """Authentication credentials for Book-A-Limo API."""
 
     id: str

bookalimo/transport/httpx_async.py

@@ -15,17 +15,21 @@ from ..config import (
     DEFAULT_TIMEOUTS,
     DEFAULT_USER_AGENT,
 )
-from ..exceptions import (
-    BookalimoConnectionError,
-    BookalimoError,
-    BookalimoHTTPError,
-    BookalimoRequestError,
-    BookalimoTimeout,
-)
+from ..logging import redact_url
 from .auth import Credentials, inject_credentials
 from .base import AsyncBaseTransport
 from .retry import async_retry, should_retry_exception, should_retry_status
-from .utils import handle_api_errors, handle_http_error
+from .utils import (
+    build_url,
+    handle_api_errors,
+    handle_http_error,
+    map_httpx_exceptions,
+    parse_json_or_raise,
+    post_log,
+    pre_log,
+    raise_if_retryable_status,
+    setup_secure_logging_and_client,
+)
 
 logger = logging.getLogger("bookalimo.transport")
 
@@ -46,7 +50,7 @@ class AsyncTransport(AsyncBaseTransport):
         backoff: float = DEFAULT_BACKOFF,
     ):
         self.base_url = base_url.rstrip("/")
-        self.credentials = credentials
+        self._credentials = credentials
         self.retries = retries
         self.backoff = backoff
         self.headers = {
@@ -54,18 +58,28 @@ class AsyncTransport(AsyncBaseTransport):
             "user-agent": user_agent,
         }
 
-        # Create client if not provided
-        self._owns_client = client is None
-        self.client = client or httpx.AsyncClient(timeout=timeouts)
+        # Setup secure logging and create client
+        self.client, self._owns_client = setup_secure_logging_and_client(
+            is_async=True, timeout=timeouts, client=client
+        )
 
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(
-                "AsyncTransport initialized (base_url=%s, timeout=%s, user_agent=%s)",
-                self.base_url,
+                "%s initialized (base_url=%s, timeout=%s, user_agent=%s)",
+                self.__class__.__name__,
+                redact_url(self.base_url),
                 timeouts,
                 user_agent,
             )
 
+    @property
+    def credentials(self) -> Optional[Credentials]:
+        return self._credentials
+
+    @credentials.setter
+    def credentials(self, credentials: Optional[Credentials]) -> None:
+        self._credentials = credentials
+
     @overload
     async def post(self, path: str, model: BaseModel) -> Any: ...
     @overload
@@ -75,30 +89,18 @@ class AsyncTransport(AsyncBaseTransport):
         self, path: str, model: BaseModel, response_model: Optional[type[T]] = None
     ) -> Union[T, Any]:
         """Make a POST request and return parsed response."""
-        # Prepare URL
-        path = path if path.startswith("/") else f"/{path}"
-        url = f"{self.base_url}{path}"
+        url = build_url(self.base_url, path)
 
-        # Prepare data and inject credentials
         data = self.prepare_data(model)
         data = inject_credentials(data, self.credentials)
 
-        # Debug logging
-        req_id = None
-        start = 0.0
-        if logger.isEnabledFor(logging.DEBUG):
-            req_id = uuid4().hex[:8]
-            start = perf_counter()
+        req_id = uuid4().hex[:8] if logger.isEnabledFor(logging.DEBUG) else None
+        start = perf_counter() if req_id else 0.0
+        if req_id:
             body_keys = sorted(k for k in data.keys() if k != "credentials")
-            logger.debug(
-                "→ [%s] POST %s body_keys=%s",
-                req_id,
-                path,
-                body_keys,
-            )
+            pre_log(url, body_keys, req_id)
 
-        try:
-            # Make request with retry logic
+        with map_httpx_exceptions(req_id, path):
             response = await async_retry(
                 lambda: self._make_request(url, data),
                 retries=self.retries,
@@ -110,121 +112,35 @@ class AsyncTransport(AsyncBaseTransport):
                 ),
             )
 
-            # Handle HTTP errors
             if response.status_code >= 400:
                 handle_http_error(response, req_id, path)
 
-            # Parse JSON
-            try:
-                json_data = response.json()
-            except ValueError as e:
-                if logger.isEnabledFor(logging.DEBUG):
-                    logger.warning("× [%s] %s invalid JSON", req_id or "-", path)
-                preview = (
-                    (response.text or "")[:256] if hasattr(response, "text") else None
-                )
-                raise BookalimoError(
-                    f"Invalid JSON response: {preview}",
-                ) from e
-
-            # Handle API-level errors
+            json_data = parse_json_or_raise(response, path, req_id)
+
             handle_api_errors(json_data, req_id, path)
 
-            # Debug logging for success
-            if logger.isEnabledFor(logging.DEBUG):
-                dur_ms = (perf_counter() - start) * 1000.0
-                reqid_hdr = response.headers.get(
-                    "x-request-id"
-                ) or response.headers.get("request-id")
-                content_len = (
-                    len(response.content) if hasattr(response, "content") else None
-                )
-                logger.debug(
-                    "← [%s] %s %s in %.1f ms len=%s reqid=%s",
-                    req_id,
-                    response.status_code,
-                    path,
-                    dur_ms,
-                    content_len,
-                    reqid_hdr,
-                )
-
-            # Parse and return response
+            if req_id:
+                post_log(url, response, start, req_id)
+
             return (
                 response_model.model_validate(json_data)
                 if response_model
                 else json_data
             )
 
-        except httpx.TimeoutException:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning("× [%s] %s timeout", req_id or "-", path)
-            raise BookalimoTimeout("Request timeout") from None
-
-        except httpx.ConnectError:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning("× [%s] %s connection error", req_id or "-", path)
-            raise BookalimoConnectionError(
-                "Connection error - unable to reach Book-A-Limo API"
-            ) from None
-        except httpx.RequestError as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s request error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            raise BookalimoRequestError(f"Request Error: {e}") from e
-
-        except httpx.HTTPStatusError as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s HTTP error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            status_code = getattr(getattr(e, "response", None), "status_code", None)
-            raise BookalimoHTTPError(f"HTTP Error: {e}", status_code=status_code) from e
-
-        except (BookalimoError, BookalimoHTTPError):
-            # Already handled above
-            raise
-
-        except Exception as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s unexpected error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            raise BookalimoError(f"Unexpected error: {str(e)}") from e
-
     async def _make_request(self, url: str, data: dict[str, Any]) -> httpx.Response:
-        """Make the actual HTTP request."""
         resp = await self.client.post(url, json=data, headers=self.headers)
-        if should_retry_status(resp.status_code):
-            # Construct an HTTPStatusError so async_retry can catch & decide.
-            raise httpx.HTTPStatusError(
-                message=f"Retryable HTTP status: {resp.status_code}",
-                request=resp.request,
-                response=resp,
-            )
+        raise_if_retryable_status(resp, should_retry_status)
         return resp
 
     async def aclose(self) -> None:
-        """Close the HTTP client if we own it."""
         if self._owns_client and not self.client.is_closed:
             await self.client.aclose()
             if logger.isEnabledFor(logging.DEBUG):
-                logger.debug("AsyncTransport HTTP client closed")
+                logger.debug("%s HTTP client closed", self.__class__.__name__)
 
     async def __aenter__(self) -> "AsyncTransport":
-        """Async context manager entry."""
         return self
 
     async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Async context manager exit."""
         await self.aclose()

bookalimo/transport/httpx_sync.py

@@ -15,17 +15,21 @@ from ..config import (
     DEFAULT_TIMEOUTS,
     DEFAULT_USER_AGENT,
 )
-from ..exceptions import (
-    BookalimoConnectionError,
-    BookalimoError,
-    BookalimoHTTPError,
-    BookalimoRequestError,
-    BookalimoTimeout,
-)
+from ..logging import redact_url
 from .auth import Credentials, inject_credentials
 from .base import BaseTransport
 from .retry import should_retry_exception, should_retry_status, sync_retry
-from .utils import handle_api_errors, handle_http_error
+from .utils import (
+    build_url,
+    handle_api_errors,
+    handle_http_error,
+    map_httpx_exceptions,
+    parse_json_or_raise,
+    post_log,
+    pre_log,
+    raise_if_retryable_status,
+    setup_secure_logging_and_client,
+)
 
 logger = logging.getLogger("bookalimo.transport")
 
@@ -54,14 +58,16 @@ class SyncTransport(BaseTransport):
             "user-agent": user_agent,
         }
 
-        # Create client if not provided
-        self._owns_client = client is None
-        self.client = client or httpx.Client(timeout=timeouts)
+        # Setup secure logging and create client
+        self.client, self._owns_client = setup_secure_logging_and_client(
+            is_async=False, timeout=timeouts, client=client
+        )
 
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(
-                "SyncTransport initialized (base_url=%s, timeout=%s, user_agent=%s)",
-                self.base_url,
+                "%s initialized (base_url=%s, timeout=%s, user_agent=%s)",
+                self.__class__.__name__,
+                redact_url(self.base_url),
                 timeouts,
                 user_agent,
             )
@@ -76,28 +82,20 @@ class SyncTransport(BaseTransport):
     ) -> Union[T, Any]:
         """Make a POST request and return parsed response."""
         # Prepare URL
-        path = path if path.startswith("/") else f"/{path}"
-        url = f"{self.base_url}{path}"
+        url = build_url(self.base_url, path)
 
         # Prepare data and inject credentials
         data = self.prepare_data(model)
         data = inject_credentials(data, self.credentials)
 
         # Debug logging
-        req_id = None
-        start = 0.0
-        if logger.isEnabledFor(logging.DEBUG):
-            req_id = uuid4().hex[:8]
-            start = perf_counter()
+        req_id = uuid4().hex[:8] if logger.isEnabledFor(logging.DEBUG) else None
+        start = perf_counter() if req_id else 0.0
+        if req_id:
             body_keys = sorted(k for k in data.keys() if k != "credentials")
-            logger.debug(
-                "→ [%s] POST %s body_keys=%s",
-                req_id,
-                path,
-                body_keys,
-            )
+            pre_log(url, body_keys, req_id)
 
-        try:
+        with map_httpx_exceptions(req_id, path):
             # Make request with retry logic
             response = sync_retry(
                 lambda: self._make_request(url, data),
@@ -115,39 +113,14 @@ class SyncTransport(BaseTransport):
                 handle_http_error(response, req_id, path)
 
             # Parse JSON
-            try:
-                json_data = response.json()
-            except ValueError as e:
-                if logger.isEnabledFor(logging.DEBUG):
-                    logger.warning("× [%s] %s invalid JSON", req_id or "-", path)
-                preview = (
-                    (response.text or "")[:256] if hasattr(response, "text") else None
-                )
-                raise BookalimoError(
-                    f"Invalid JSON response: {preview}",
-                ) from e
+            json_data = parse_json_or_raise(response, path, req_id)
 
             # Handle API-level errors
             handle_api_errors(json_data, req_id, path)
 
             # Debug logging for success
-            if logger.isEnabledFor(logging.DEBUG):
-                dur_ms = (perf_counter() - start) * 1000.0
-                reqid_hdr = response.headers.get(
-                    "x-request-id"
-                ) or response.headers.get("request-id")
-                content_len = (
-                    len(response.content) if hasattr(response, "content") else None
-                )
-                logger.debug(
-                    "← [%s] %s %s in %.1f ms len=%s reqid=%s",
-                    req_id,
-                    response.status_code,
-                    path,
-                    dur_ms,
-                    content_len,
-                    reqid_hdr,
-                )
+            if req_id:
+                post_log(url, response, start, req_id)
 
             # Parse and return response
             return (
@@ -156,62 +129,10 @@ class SyncTransport(BaseTransport):
                 else json_data
             )
 
-        except httpx.TimeoutException:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning("× [%s] %s timeout", req_id or "-", path)
-            raise BookalimoTimeout("Request timeout") from None
-
-        except httpx.ConnectError:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning("× [%s] %s connection error", req_id or "-", path)
-            raise BookalimoConnectionError(
-                "Connection error - unable to reach Book-A-Limo API"
-            ) from None
-        except httpx.RequestError as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s request error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            raise BookalimoRequestError(f"Request Error: {e}") from e
-
-        except httpx.HTTPStatusError as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s HTTP error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            status_code = getattr(getattr(e, "response", None), "status_code", None)
-            raise BookalimoHTTPError(f"HTTP Error: {e}", status_code=status_code) from e
-
-        except (BookalimoError, BookalimoHTTPError):
-            # Already handled above
-            raise
-
-        except Exception as e:
-            if logger.isEnabledFor(logging.DEBUG):
-                logger.warning(
-                    "× [%s] %s unexpected error: %s",
-                    req_id or "-",
-                    path,
-                    e.__class__.__name__,
-                )
-            raise BookalimoError(f"Unexpected error: {str(e)}") from e
-
     def _make_request(self, url: str, data: dict[str, Any]) -> httpx.Response:
         """Make the actual HTTP request."""
         resp = self.client.post(url, json=data, headers=self.headers)
-        if should_retry_status(resp.status_code):
-            # Construct an HTTPStatusError so sync_retry can catch & decide.
-            raise httpx.HTTPStatusError(
-                message=f"Retryable HTTP status: {resp.status_code}",
-                request=resp.request,
-                response=resp,
-            )
+        raise_if_retryable_status(resp, should_retry_status)
         return resp
 
     def close(self) -> None:
@@ -219,7 +140,7 @@ class SyncTransport(BaseTransport):
         if self._owns_client and not self.client.is_closed:
             self.client.close()
             if logger.isEnabledFor(logging.DEBUG):
-                logger.debug("SyncTransport HTTP client closed")
+                logger.debug("%s HTTP client closed", self.__class__.__name__)
 
     def __enter__(self) -> "SyncTransport":
         """Context manager entry."""