bookalimo 1.0.0__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/config.py

@@ -5,7 +5,7 @@ from ._version import __version__
 # Default API configuration
 DEFAULT_BASE_URL = "https://www.bookalimo.com/web/api"
 DEFAULT_TIMEOUT = 5.0
-DEFAULT_USER_AGENT = f"bookalimo-python/{__version__} (+https://github.com/asparagusbeef/bookalimo-python)"
+DEFAULT_USER_AGENT = f"bookalimo-python/{__version__}"
 
 # Default retry configuration
 DEFAULT_RETRIES = 2

bookalimo/integrations/google_places/client_async.py

@@ -1,30 +1,29 @@
 from __future__ import annotations
 
-import re
 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.api_core.client_options import ClientOptions
 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 ...schemas.places.place import Place as GooglePlace
 from .common import (
-    ADDRESS_TYPES,
     DEFAULT_PLACE_FIELDS,
-    DEFAULT_PLACE_LIST_FIELDS,
-    Fields,
-    PlaceListFields,
-    fmt_exc,
-    mask_header,
+    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,
 )
-from .proto_adapter import validate_proto_to_model
+from .transports import GoogleAsyncTransport
 
 logger = get_logger("places")
 
@@ -32,40 +31,9 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-def _strip_html(s: str) -> str:
-    # Simple fallback for adr_format_address (which is HTML)
-    return re.sub(r"<[^>]+>", "", s) if s else s
-
-
-def _infer_place_type(m: GooglePlace) -> str:
-    # 1) Airport wins outright
-    tset = set(m.types or [])
-    ptype = (m.primary_type or "").lower() if getattr(m, "primary_type", None) else ""
-    if "airport" in tset or ptype == "airport":
-        return "airport"
-    # 2) Anything that looks like a geocoded address
-    if tset & ADDRESS_TYPES:
-        return "address"
-    # 3) Otherwise treat as a point of interest
-    return "poi"
-
-
-def _get_lat_lng(model: GooglePlace) -> tuple[float, float]:
-    if model.location:
-        lat = model.location.latitude
-        lng = model.location.longitude
-    elif model.viewport:
-        lat = model.viewport.low.latitude
-        lng = model.viewport.low.longitude
-    else:
-        lat = 0
-        lng = 0
-    return lat, lng
-
-
 class AsyncGooglePlaces:
     """
-    Google Places API client for address validation, geocoding, and autocomplete.
+    Google Places API asynchronous client for address validation, geocoding, and autocomplete.
     Provides location resolution services that integrate seamlessly with
     Book-A-Limo location factory functions.
     """
@@ -84,15 +52,10 @@ class AsyncGooglePlaces:
             http_client: Optional `httpx.AsyncClient` instance.
         """
         self.http_client = http_client or httpx.AsyncClient()
-        if client:
-            self.client = client
-        else:
-            api_key = api_key or getenv("GOOGLE_PLACES_API_KEY")
-            if not api_key:
-                raise ValueError("Google Places API key is required.")
-            self.client = PlacesAsyncClient(
-                client_options=ClientOptions(api_key=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(self.api_key, client)
 
     async def __aenter__(self) -> AsyncGooglePlaces:
         return self
@@ -108,151 +71,173 @@ class AsyncGooglePlaces:
     async def aclose(self) -> None:
         """Close underlying transports safely."""
         try:
-            await self.client.transport.close()
+            await self.transport.close()
         finally:
             await self.http_client.aclose()
 
     async def autocomplete(
-        self, request: models.AutocompletePlacesRequest, **kwargs: Any
+        self,
+        input: Optional[str] = None,
+        *,
+        request: Optional[models.AutocompletePlacesRequest] = None,
     ) -> models.AutocompletePlacesResponse:
         """
         Get autocomplete suggestions for a location query.
         Args:
+            input: The text string on which to search.
             request: AutocompletePlacesRequest object.
-            **kwargs: Additional parameters for the Google Places Autocomplete API.
         Returns:
             `AutocompletePlacesResponse` object.
+        Note:
+            If both input and request are provided, request will be used.
         Raises:
+            ValueError: If neither input nor request is provided, or if both are provided.
             BookalimoError: If the API request fails.
         """
-        try:
-            proto = await self.client.autocomplete_places(
-                request=request.model_dump(), **kwargs
-            )
-            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
+        request = validate_autocomplete_inputs(input, request)
+        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,
-        query: str,
+        query: Optional[str] = None,
         *,
-        fields: PlaceListFields = DEFAULT_PLACE_LIST_FIELDS,
+        request: Optional[models.SearchTextRequest] = None,
+        fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
         **kwargs: Any,
     ) -> list[models.Place]:
         """
-        Search for places using a text query.
+        Search for places using a text query or SearchTextRequest.
         Args:
-            query: The text query to search for.
+            query: Simple text query to search for. Either query or request must be provided.
+            request: SearchTextRequest object with advanced search parameters. Either query or request must be provided.
+            fields: Field mask for response data.
             **kwargs: Additional parameters for the Text Search API.
         Returns:
             list[models.Place]
         Raises:
             BookalimoError: If the API request fails.
+            ValueError: If neither query nor request is provided, or if both are provided.
         """
-        metadata = mask_header(fields)
-        try:
-            protos = await self.client.search_text(
-                request={"text_query": query, **kwargs},
-                metadata=metadata,
-            )
-            pydantic_models = [
-                validate_proto_to_model(proto, GooglePlace) for proto in protos.places
-            ]
-            place_models: list[models.Place] = []
-            for model in pydantic_models:
-                adr_format = getattr(model, "adr_format_address", None)
-                addr = (
-                    getattr(model, "formatted_address", None)
-                    or getattr(model, "short_formatted_address", None)
-                    or _strip_html(adr_format or "")
-                    or ""
-                )
-                lat, lng = _get_lat_lng(model)
-                place_models.append(
-                    models.Place(
-                        formatted_address=addr,
-                        lat=lat,
-                        lng=lng,
-                        place_type=_infer_place_type(model),
-                        iata_code=None,
-                        google_place=model,
-                    )
-                )
-            return place_models
-        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,
-        place_id: models.GetPlaceRequest,
+        place_id: Optional[str] = None,
         *,
-        fields: Fields = DEFAULT_PLACE_FIELDS,
-        **kwargs: Any,
+        request: Optional[models.GetPlaceRequest] = None,
+        fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
     ) -> Optional[models.Place]:
         """
         Get details for a specific place.
         Args:
             place_id: The ID of the place to retrieve details for.
-            **kwargs: Additional parameters for the Get Place API.
+            request: GetPlaceRequest object with place resource name.
+            fields: Optional field mask for response data.
         Returns:
             A models.Place object or None if not found.
         Raises:
+            ValueError: If neither place_id nor request is provided.
             BookalimoError: If the API request fails.
         """
-        metadata = mask_header(fields)
-        try:
-            proto = await self.client.get_place(
-                request={"name": f"places/{place_id}", **kwargs},
-                metadata=metadata,
-            )
-            # Convert proto to GooglePlace first, then process like search
-            model = validate_proto_to_model(proto, GooglePlace)
-            adr_format = getattr(model, "adr_format_address", None)
-            addr = (
-                getattr(model, "formatted_address", None)
-                or getattr(model, "short_formatted_address", None)
-                or _strip_html(adr_format or "")
-                or ""
+        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,
+        text_weight: float = 0.5,
+    ) -> list[models.ResolvedAirport]:
+        """
+        Resolve airport candidates given either a natural language text query, a place_id, or a list of Places.
+
+        Args:
+            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)
+            text_weight: Weight for text search (default: 0.5) If 0.0, only proximity will be used. If 1.0, only text will be used.
+
+        Rules:
+        - Provide at most one of {place_id, places}. (query may accompany either.)
+        - If nothing but query is given, search for places from the query.
+        - If place_id is given:
+            * Fetch the place.
+            * If no explicit query, derive it from the place's display name.
+        - If places is given:
+            * If len(places) == 0 and no query, error.
+            * If len(places) == 1 and no query, derive query from that place's display name.
+            * If len(places) > 1 and no query, error (need query to disambiguate).
+        - If nothing is provided, error.
+        - If max_distance_km is provided, it must be > 0.
+
+        Returns:
+            list[models.ResolvedAirport]
+        Raises:
+            ValueError on invalid inputs.
+            BookalimoError if underlying API requests fail.
+        """
+        # 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
             )
-            lat, lng = _get_lat_lng(model)
-            return models.Place(
-                formatted_address=addr,
-                lat=lat,
-                lng=lng,
-                place_type=_infer_place_type(model),
-                iata_code=None,
-                google_place=model,
+        )
+
+        # 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 needs_call and preprocessed_places == []:
+            # Need to perform search
+            effective_places = await self.search(
+                request=create_search_text_request(
+                    query=str(preprocessed_query).strip(),
+                    region_code=country_code,
+                )
             )
-        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
+        else:
+            effective_places = preprocessed_places
+
+        # Handle postprocessing
+        return handle_resolve_airport_postprocessing(
+            preprocessed_query,
+            effective_places,
+            max_distance_km,
+            max_results,
+            confidence_threshold,
+            text_weight,
+        )