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

bookalimo/client.py

@@ -59,7 +59,7 @@ class AsyncBookalimo:
             google_places_api_key="your-google-api-key"
         ) as client:
             # Find locations using Google Places
-            places = await client.places.search_text("Empire State Building")
+            places = await client.places.search("Empire State Building")
 
             # Use in booking
             quote = await client.pricing.quote(
@@ -93,8 +93,7 @@ class AsyncBookalimo:
             transport: Custom transport instance (optional)
             google_places_api_key: Google Places API key for location services (optional)
         """
-
-        transport_credentials = transport.credentials if transport else None
+        transport_credentials = transport._credentials if transport else None
 
         both_provided = all([transport_credentials, credentials])
         both_missing = not any([transport_credentials, credentials])
@@ -113,18 +112,21 @@ class AsyncBookalimo:
                 stacklevel=2,
             )
 
-        # Use whichever exists when we need to build a transport ourselves
         effective_credentials = (
-            credentials if credentials is not None else transport_credentials
+            transport_credentials if transport_credentials is not None else credentials
         )
+
         if transport:
-            transport.credentials = effective_credentials
-        self._transport = transport or AsyncTransport(
-            base_url=base_url,
-            timeouts=timeouts,
-            user_agent=user_agent,
-            credentials=effective_credentials,
-        )
+            if transport_credentials is None and credentials is not None:
+                transport.credentials = credentials
+            self._transport = transport
+        else:
+            self._transport = AsyncTransport(
+                base_url=base_url,
+                timeouts=timeouts,
+                user_agent=user_agent,
+                credentials=effective_credentials,
+            )
 
         # Initialize service instances
         self.reservations = AsyncReservationsService(self._transport)
@@ -149,7 +151,7 @@ class AsyncBookalimo:
             Auth priority is as follows:
               - provided api key in constructor
               - GOOGLE_PLACES_API_KEY environment variable
-              - Google ADC - Except for Geocoding API.
+              - Google ADC - Not yet implemented.
         """
         if not _GOOGLE_PLACES_AVAILABLE:
             raise ImportError(
@@ -207,7 +209,7 @@ class Bookalimo:
             google_places_api_key="your-google-api-key"
         ) as client:
             # Find locations using Google Places
-            places = client.places.search_text("Empire State Building")
+            places = client.places.search("Empire State Building")
 
             # Use in booking
             quote = client.pricing.quote(
@@ -241,20 +243,41 @@ class Bookalimo:
             transport: Custom transport instance (optional)
             google_places_api_key: Google Places API key for location services (optional)
         """
-        if transport and transport.credentials is not None and credentials is not None:
+        transport_credentials = transport.credentials if transport else None
+
+        both_provided = all([transport_credentials, credentials])
+        both_missing = not any([transport_credentials, credentials])
+
+        if both_provided:
             warnings.warn(
                 "Credentials provided in both transport and constructor. "
                 "The transport credentials will be used.",
-                UserWarning,
+                DuplicateCredentialsWarning,
                 stacklevel=2,
             )
-        self._transport = transport or SyncTransport(
-            base_url=base_url,
-            timeouts=timeouts,
-            user_agent=user_agent,
-            credentials=credentials,
+        elif both_missing:
+            warnings.warn(
+                "No credentials provided in transport or constructor; proceeding unauthenticated.",
+                MissingCredentialsWarning,
+                stacklevel=2,
+            )
+
+        effective_credentials = (
+            transport_credentials if transport_credentials is not None else credentials
         )
 
+        if transport:
+            if transport_credentials is None and credentials is not None:
+                transport.credentials = credentials
+            self._transport = transport
+        else:
+            self._transport = SyncTransport(
+                base_url=base_url,
+                timeouts=timeouts,
+                user_agent=user_agent,
+                credentials=effective_credentials,
+            )
+
         # Initialize service instances
         self.reservations = ReservationsService(self._transport)
         self.pricing = PricingService(self._transport)
@@ -278,7 +301,7 @@ class Bookalimo:
             Auth priority is as follows:
               - provided api key in constructor
               - GOOGLE_PLACES_API_KEY environment variable
-              - Google ADC - Except for Geocoding API.
+              - Google ADC - Not yet implemented.
         """
         if not _GOOGLE_PLACES_AVAILABLE:
             raise ImportError(

bookalimo/integrations/google_places/client_async.py

@@ -2,31 +2,27 @@ from __future__ import annotations
 
 from os import getenv
 from types import TracebackType
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, Optional, TypeVar
 
 import httpx
-from google.api_core import exceptions as gexc
 from google.maps.places_v1 import PlacesAsyncClient
 from typing_extensions import ParamSpec
 
-from ...exceptions import BookalimoError
 from ...logging import get_logger
 from ...schemas.places import FieldMaskInput
 from ...schemas.places import google as models
 from .common import (
     DEFAULT_PLACE_FIELDS,
-    build_get_place_request,
-    build_search_request_params,
-    derive_effective_query,
-    fmt_exc,
-    mask_header,
-    normalize_place_from_proto,
-    normalize_search_results,
+    create_search_text_request,
+    handle_autocomplete_impl_async,
+    handle_geocode_response,
+    handle_get_place_impl_async,
+    handle_resolve_airport_postprocessing,
+    handle_resolve_airport_preprocessing,
+    handle_search_impl_async,
+    prepare_geocode_params,
     validate_autocomplete_inputs,
-    validate_resolve_airport_inputs,
 )
-from .proto_adapter import validate_proto_to_model
-from .resolve_airport import resolve_airport
 from .transports import GoogleAsyncTransport
 
 logger = get_logger("places")
@@ -56,10 +52,10 @@ class AsyncGooglePlaces:
             http_client: Optional `httpx.AsyncClient` instance.
         """
         self.http_client = http_client or httpx.AsyncClient()
-        api_key = api_key or getenv("GOOGLE_PLACES_API_KEY")
-        if not api_key:
+        self.api_key = api_key or getenv("GOOGLE_PLACES_API_KEY")
+        if not self.api_key:
             raise ValueError("Google Places API key is required.")
-        self.transport = GoogleAsyncTransport(api_key, client)
+        self.transport = GoogleAsyncTransport(self.api_key, client)
 
     async def __aenter__(self) -> AsyncGooglePlaces:
         return self
@@ -99,28 +95,19 @@ class AsyncGooglePlaces:
             BookalimoError: If the API request fails.
         """
         request = validate_autocomplete_inputs(input, request)
-        try:
-            proto = await self.transport.autocomplete_places(
-                request=request.model_dump()
-            )
-            return validate_proto_to_model(proto, models.AutocompletePlacesResponse)
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Autocomplete failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return await handle_autocomplete_impl_async(
+            lambda req: self.transport.autocomplete_places(request=req),
+            request,
+        )
 
     async def geocode(self, request: models.GeocodingRequest) -> dict[str, Any]:
-        try:
-            r = await self.http_client.get(
-                "https://maps.googleapis.com/maps/api/geocode/json",
-                params=request.to_query_params(),
-            )
-            r.raise_for_status()
-            return cast(dict[str, Any], r.json())
-        except httpx.HTTPError as e:
-            msg = f"HTTP geocoding failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        assert self.api_key is not None  # Validated in __init__
+        params = prepare_geocode_params(request, self.api_key)
+        r = await self.http_client.get(
+            "https://maps.googleapis.com/maps/api/geocode/json",
+            params=params,
+        )
+        return handle_geocode_response(r)
 
     async def search(
         self,
@@ -143,24 +130,13 @@ class AsyncGooglePlaces:
             BookalimoError: If the API request fails.
             ValueError: If neither query nor request is provided, or if both are provided.
         """
-        request_params = build_search_request_params(query, request, **kwargs)
-        metadata = mask_header(fields, prefix="places")
-
-        try:
-            protos = await self.transport.search_text(
-                request=request_params,
-                metadata=metadata,
-            )
-            return normalize_search_results(protos)
-        except gexc.InvalidArgument as e:
-            # Often caused by missing/invalid field mask
-            msg = f"Google Places Text Search invalid argument: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Text Search failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return await handle_search_impl_async(
+            lambda req, meta: self.transport.search_text(request=req, metadata=meta),
+            query,
+            request,
+            fields,
+            **kwargs,
+        )
 
     async def get(
         self,
@@ -181,31 +157,19 @@ class AsyncGooglePlaces:
             ValueError: If neither place_id nor request is provided.
             BookalimoError: If the API request fails.
         """
-        request_params = build_get_place_request(place_id, request)
-        metadata = mask_header(fields)
-
-        try:
-            proto = await self.transport.get_place(
-                request=request_params,
-                metadata=metadata,
-            )
-            return normalize_place_from_proto(proto)
-        except gexc.NotFound:
-            return None
-        except gexc.InvalidArgument as e:
-            msg = f"Google Places Get Place invalid argument: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Get Place failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return await handle_get_place_impl_async(
+            lambda req, meta: self.transport.get_place(request=req, metadata=meta),
+            place_id,
+            request,
+            fields,
+        )
 
     async def resolve_airport(
         self,
         query: Optional[str] = None,
         place_id: Optional[str] = None,
         places: Optional[list[models.Place]] = None,
+        country_code: Optional[str] = None,
         max_distance_km: Optional[float] = 100,
         max_results: Optional[int] = 5,
         confidence_threshold: Optional[float] = 0.5,
@@ -218,6 +182,7 @@ class AsyncGooglePlaces:
             query: Text query for airport search (optional)
             place_id: Google place ID for proximity matching (optional)
             places: List of existing Place objects for proximity matching (optional)
+            country_code: Country code for proximity matching (optional)
             max_distance_km: Maximum distance for proximity matching (default: 100km)
             max_results: Maximum number of results to return (default: 5)
             confidence_threshold: Minimum confidence threshold (default: 0.5)
@@ -242,46 +207,35 @@ class AsyncGooglePlaces:
             ValueError on invalid inputs.
             BookalimoError if underlying API requests fail.
         """
-        # Validate inputs
-        validate_resolve_airport_inputs(place_id, places, max_distance_km)
+        # Handle preprocessing that doesn't depend on sync/async
+        preprocessed_query, preprocessed_places, needs_call = (
+            handle_resolve_airport_preprocessing(
+                query, place_id, places, max_distance_km
+            )
+        )
 
-        # Establish the authoritative places list
+        # Handle the calls that do depend on sync/async
         effective_places: list[models.Place]
-
         if place_id is not None:
             place = await self.get(place_id=place_id)
             if place is None:
                 raise ValueError(f"Place with id {place_id!r} was not found.")
             effective_places = [place]
-
-        elif places is not None:
-            if len(places) == 0 and (query is None or not str(query).strip()):
-                raise ValueError(
-                    "Empty 'places' and no 'query' provided; nothing to resolve."
-                )
-            effective_places = places
-
-        else:
-            # Neither place_id nor places: fall back to query-driven search
-            if query is None or not str(query).strip():
-                raise ValueError("Either place_id, places, or query must be provided.")
+        elif needs_call and preprocessed_places == []:
+            # Need to perform search
             effective_places = await self.search(
-                request=models.SearchTextRequest(
-                    text_query=str(query).strip(),
-                    max_result_count=5,
+                request=create_search_text_request(
+                    query=str(preprocessed_query).strip(),
+                    region_code=country_code,
                 )
             )
+        else:
+            effective_places = preprocessed_places
 
-        # Derive effective query
-        effective_query = derive_effective_query(query, effective_places)
-
-        google_places = [
-            p.google_place for p in effective_places if p.google_place is not None
-        ]
-
-        return resolve_airport(
-            effective_query,
-            google_places,
+        # Handle postprocessing
+        return handle_resolve_airport_postprocessing(
+            preprocessed_query,
+            effective_places,
             max_distance_km,
             max_results,
             confidence_threshold,

bookalimo/integrations/google_places/client_sync.py

@@ -2,31 +2,27 @@ from __future__ import annotations
 
 from os import getenv
 from types import TracebackType
-from typing import Any, Optional, TypeVar, cast
+from typing import Any, Optional, TypeVar
 
 import httpx
-from google.api_core import exceptions as gexc
 from google.maps.places_v1 import PlacesClient
 from typing_extensions import ParamSpec
 
-from ...exceptions import BookalimoError
 from ...logging import get_logger
 from ...schemas.places import FieldMaskInput
 from ...schemas.places import google as models
 from .common import (
     DEFAULT_PLACE_FIELDS,
-    build_get_place_request,
-    build_search_request_params,
-    derive_effective_query,
-    fmt_exc,
-    mask_header,
-    normalize_place_from_proto,
-    normalize_search_results,
+    create_search_text_request,
+    handle_autocomplete_impl,
+    handle_geocode_response,
+    handle_get_place_impl,
+    handle_resolve_airport_postprocessing,
+    handle_resolve_airport_preprocessing,
+    handle_search_impl,
+    prepare_geocode_params,
     validate_autocomplete_inputs,
-    validate_resolve_airport_inputs,
 )
-from .proto_adapter import validate_proto_to_model
-from .resolve_airport import resolve_airport
 from .transports import GoogleSyncTransport
 
 logger = get_logger("places")
@@ -56,10 +52,10 @@ class GooglePlaces:
             http_client: Optional `httpx.Client` instance.
         """
         self.http_client = http_client or httpx.Client()
-        api_key = api_key or getenv("GOOGLE_PLACES_API_KEY")
-        if not api_key:
+        self.api_key = api_key or getenv("GOOGLE_PLACES_API_KEY")
+        if not self.api_key:
             raise ValueError("Google Places API key is required.")
-        self.transport = GoogleSyncTransport(api_key, client)
+        self.transport = GoogleSyncTransport(self.api_key, client)
 
     def __enter__(self) -> GooglePlaces:
         return self
@@ -99,26 +95,19 @@ class GooglePlaces:
             BookalimoError: If the API request fails.
         """
         request = validate_autocomplete_inputs(input, request)
-        try:
-            proto = self.transport.autocomplete_places(request=request.model_dump())
-            return validate_proto_to_model(proto, models.AutocompletePlacesResponse)
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Autocomplete failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return handle_autocomplete_impl(
+            lambda req: self.transport.autocomplete_places(request=req),
+            request,
+        )
 
     def geocode(self, request: models.GeocodingRequest) -> dict[str, Any]:
-        try:
-            r = self.http_client.get(
-                "https://maps.googleapis.com/maps/api/geocode/json",
-                params=request.to_query_params(),
-            )
-            r.raise_for_status()
-            return cast(dict[str, Any], r.json())
-        except httpx.HTTPError as e:
-            msg = f"HTTP geocoding failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        assert self.api_key is not None  # Validated in __init__
+        params = prepare_geocode_params(request, self.api_key)
+        r = self.http_client.get(
+            "https://maps.googleapis.com/maps/api/geocode/json",
+            params=params,
+        )
+        return handle_geocode_response(r)
 
     def search(
         self,
@@ -141,24 +130,13 @@ class GooglePlaces:
             BookalimoError: If the API request fails.
             ValueError: If neither query nor request is provided, or if both are provided.
         """
-        request_params = build_search_request_params(query, request, **kwargs)
-        metadata = mask_header(fields, prefix="places")
-
-        try:
-            protos = self.transport.search_text(
-                request=request_params,
-                metadata=metadata,
-            )
-            return normalize_search_results(protos)
-        except gexc.InvalidArgument as e:
-            # Often caused by missing/invalid field mask
-            msg = f"Google Places Text Search invalid argument: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Text Search failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return handle_search_impl(
+            lambda req, meta: self.transport.search_text(request=req, metadata=meta),
+            query,
+            request,
+            fields,
+            **kwargs,
+        )
 
     def get(
         self,
@@ -179,31 +157,19 @@ class GooglePlaces:
             ValueError: If neither place_id nor request is provided.
             BookalimoError: If the API request fails.
         """
-        request_params = build_get_place_request(place_id, request)
-        metadata = mask_header(fields)
-
-        try:
-            proto = self.transport.get_place(
-                request=request_params,
-                metadata=metadata,
-            )
-            return normalize_place_from_proto(proto)
-        except gexc.NotFound:
-            return None
-        except gexc.InvalidArgument as e:
-            msg = f"Google Places Get Place invalid argument: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
-        except gexc.GoogleAPICallError as e:
-            msg = f"Google Places Get Place failed: {fmt_exc(e)}"
-            logger.error(msg)
-            raise BookalimoError(msg) from e
+        return handle_get_place_impl(
+            lambda req, meta: self.transport.get_place(request=req, metadata=meta),
+            place_id,
+            request,
+            fields,
+        )
 
     def resolve_airport(
         self,
         query: Optional[str] = None,
         place_id: Optional[str] = None,
         places: Optional[list[models.Place]] = None,
+        country_code: Optional[str] = None,
         max_distance_km: Optional[float] = 100,
         max_results: Optional[int] = 5,
         confidence_threshold: Optional[float] = 0.5,
@@ -216,6 +182,7 @@ class GooglePlaces:
             query: Text query for airport search (optional)
             place_id: Google place ID for proximity matching (optional)
             places: List of existing Place objects for proximity matching (optional)
+            country_code: Country code for proximity matching (optional)
             max_distance_km: Maximum distance for proximity matching (default: 100km)
             max_results: Maximum number of results to return (default: 5)
             confidence_threshold: Minimum confidence threshold (default: 0.5)
@@ -240,46 +207,35 @@ class GooglePlaces:
             ValueError on invalid inputs.
             BookalimoError if underlying API requests fail.
         """
-        # Validate inputs
-        validate_resolve_airport_inputs(place_id, places, max_distance_km)
+        # Handle preprocessing that doesn't depend on sync/async
+        preprocessed_query, preprocessed_places, needs_call = (
+            handle_resolve_airport_preprocessing(
+                query, place_id, places, max_distance_km
+            )
+        )
 
-        # Establish the authoritative places list
+        # Handle the calls that do depend on sync/async
         effective_places: list[models.Place]
-
         if place_id is not None:
             place = self.get(place_id=place_id)
             if place is None:
                 raise ValueError(f"Place with id {place_id!r} was not found.")
             effective_places = [place]
-
-        elif places is not None:
-            if len(places) == 0 and (query is None or not str(query).strip()):
-                raise ValueError(
-                    "Empty 'places' and no 'query' provided; nothing to resolve."
-                )
-            effective_places = places
-
-        else:
-            # Neither place_id nor places: fall back to query-driven search
-            if query is None or not str(query).strip():
-                raise ValueError("Either place_id, places, or query must be provided.")
+        elif needs_call and preprocessed_places == []:
+            # Need to perform search
             effective_places = self.search(
-                request=models.SearchTextRequest(
-                    text_query=str(query).strip(),
-                    max_result_count=5,
+                request=create_search_text_request(
+                    query=str(preprocessed_query).strip(),
+                    region_code=country_code,
                 )
             )
+        else:
+            effective_places = preprocessed_places
 
-        # Derive effective query
-        effective_query = derive_effective_query(query, effective_places)
-
-        google_places = [
-            p.google_place for p in effective_places if p.google_place is not None
-        ]
-
-        return resolve_airport(
-            effective_query,
-            google_places,
+        # Handle postprocessing
+        return handle_resolve_airport_postprocessing(
+            preprocessed_query,
+            effective_places,
             max_distance_km,
             max_results,
             confidence_threshold,