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

bookalimo/integrations/google_places/client_sync.py

@@ -1,29 +1,29 @@
 from __future__ import annotations
 
-import re
-from collections.abc import Sequence
 from os import getenv
-from typing import Any, Optional, TypeVar, cast
+from types import TracebackType
+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 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 ...schemas.places.place import Place as GooglePlace
 from .common import (
-    ADDRESS_TYPES,
     DEFAULT_PLACE_FIELDS,
-    DEFAULT_PLACE_LIST_FIELDS,
-    PlaceListFields,
-    fmt_exc,
-    mask_header,
+    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,
 )
-from .proto_adapter import validate_proto_to_model
+from .transports import GoogleSyncTransport
 
 logger = get_logger("places")
 
@@ -31,37 +31,6 @@ 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 GooglePlaces:
     """
     Google Places API synchronous client for address validation, geocoding, and autocomplete.
@@ -83,15 +52,10 @@ class GooglePlaces:
             http_client: Optional `httpx.Client` instance.
         """
         self.http_client = http_client or httpx.Client()
-        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 = PlacesClient(
-                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 = GoogleSyncTransport(self.api_key, client)
 
     def __enter__(self) -> GooglePlaces:
         return self
@@ -100,158 +64,180 @@ class GooglePlaces:
         self,
         exc_type: Optional[type[BaseException]],
         exc_val: Optional[BaseException],
-        exc_tb: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
     ) -> None:
         self.close()
 
     def close(self) -> None:
         """Close underlying transports safely."""
         try:
-            self.client.transport.close()
+            self.transport.close()
         finally:
             self.http_client.close()
 
     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 = 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 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,
-        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 = 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 handle_search_impl(
+            lambda req, meta: self.transport.search_text(request=req, metadata=meta),
+            query,
+            request,
+            fields,
+            **kwargs,
+        )
 
     def get(
         self,
-        place_id: models.GetPlaceRequest,
+        place_id: Optional[str] = None,
         *,
-        fields: Sequence[str] | str = 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 = 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 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,
+        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 = 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 = 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,
+        )