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

bookalimo/integrations/google_places/common.py

@@ -5,8 +5,12 @@ Common utilities and shared functionality for Google Places clients.
 from __future__ import annotations
 
 import re
-from typing import Any, Optional
+from typing import Any, Awaitable, Callable, Optional, cast
 
+import httpx
+from google.api_core import exceptions as gexc
+
+from ...exceptions import BookalimoError
 from ...logging import get_logger
 from ...schemas.places import (
     AddressComponent,
@@ -15,14 +19,19 @@ from ...schemas.places import (
     GooglePlace,
     Place,
     PlaceType,
+    RankPreference,
     compile_field_mask,
 )
 from ...schemas.places import (
     google as models,
 )
+from .proto_adapter import validate_proto_to_model
+from .resolve_airport import resolve_airport
 
 logger = get_logger("places")
 
+# Type variables for shared functionality
+
 # Default field mask for places queries
 DEFAULT_PLACE_FIELDS = (
     "display_name",
@@ -49,12 +58,12 @@ ADDRESS_TYPES = {
 }
 
 
-def fmt_exc(e: BaseException) -> str:
+def _fmt_exc(e: BaseException) -> str:
     """Format exception for logging without touching non-existent attributes."""
     return f"{type(e).__name__}: {e}"
 
 
-def mask_header(
+def _mask_header(
     fields: FieldMaskInput, prefix: str = ""
 ) -> tuple[tuple[str, str], ...]:
     """
@@ -127,7 +136,7 @@ def name_from_place(p: Place) -> Optional[str]:
     return None
 
 
-def build_search_request_params(
+def _build_search_request_params(
     query: Optional[str],
     request: Optional[models.SearchTextRequest],
     **kwargs: Any,
@@ -148,9 +157,8 @@ def build_search_request_params(
         return {"text_query": query, **kwargs}
 
 
-def normalize_place_from_proto(proto: Any) -> models.Place:
+def _normalize_place_from_proto(proto: Any) -> models.Place:
     """Convert a proto Place to our normalized Place model."""
-    from .proto_adapter import validate_proto_to_model
 
     model = validate_proto_to_model(proto, GooglePlace)
     adr_format = getattr(model, "adr_format_address", None)
@@ -170,12 +178,12 @@ def normalize_place_from_proto(proto: Any) -> models.Place:
     )
 
 
-def normalize_search_results(proto_response: Any) -> list[models.Place]:
+def _normalize_search_results(proto_response: Any) -> list[models.Place]:
     """Convert search_text response to list of normalized Place models."""
-    return [normalize_place_from_proto(proto) for proto in proto_response.places]
+    return [_normalize_place_from_proto(proto) for proto in proto_response.places]
 
 
-def build_get_place_request(
+def _build_get_place_request(
     place_id: Optional[str], request: Optional[models.GetPlaceRequest]
 ) -> dict[str, Any]:
     """Build request parameters for get_place API call."""
@@ -183,12 +191,12 @@ def build_get_place_request(
         raise ValueError("Either 'place_id' or 'request' must be provided")
 
     if request:
-        return request.model_dump(exclude_none=True)
+        return request.model_dump(exclude_none=True, context={"enum_out": "name"})
     else:
         return {"name": f"places/{place_id}"}
 
 
-def derive_effective_query(query: Optional[str], places: list[models.Place]) -> str:
+def _derive_effective_query(query: Optional[str], places: list[models.Place]) -> str:
     """Derive an effective query string from query and/or places."""
     effective_query = (query or "").strip()
 
@@ -206,7 +214,7 @@ def derive_effective_query(query: Optional[str], places: list[models.Place]) ->
     return effective_query
 
 
-def validate_resolve_airport_inputs(
+def _validate_resolve_airport_inputs(
     place_id: Optional[str],
     places: Optional[list[models.Place]],
     max_distance_km: Optional[float],
@@ -229,3 +237,273 @@ def validate_autocomplete_inputs(
         else:
             request = models.AutocompletePlacesRequest(input=input)
     return request
+
+
+def _call_gplaces_sync(
+    ctx: str,
+    fn: Callable[..., Any],
+    *args: Any,
+    not_found_ok: bool = False,
+    **kwargs: Any,
+) -> Any:
+    try:
+        return fn(*args, **kwargs)
+    except gexc.NotFound:
+        if not_found_ok:
+            return None
+        raise BookalimoError(f"{ctx} not found") from None
+    except gexc.InvalidArgument as e:
+        msg = f"{ctx} invalid argument: {_fmt_exc(e)}"
+        logger.error(msg)
+        raise BookalimoError(msg) from e
+    except gexc.GoogleAPICallError as e:
+        msg = f"{ctx} failed: {_fmt_exc(e)}"
+        logger.error(msg)
+        raise BookalimoError(msg) from e
+
+
+async def _call_gplaces_async(
+    ctx: str,
+    fn: Callable[..., Awaitable[Any]],
+    *args: Any,
+    not_found_ok: bool = False,
+    **kwargs: Any,
+) -> Any:
+    try:
+        return await fn(*args, **kwargs)
+    except gexc.NotFound:
+        if not_found_ok:
+            return None
+        raise BookalimoError(f"{ctx} not found") from None
+    except gexc.InvalidArgument as e:
+        msg = f"{ctx} invalid argument: {_fmt_exc(e)}"
+        logger.error(msg)
+        raise BookalimoError(msg) from e
+    except gexc.GoogleAPICallError as e:
+        msg = f"{ctx} failed: {_fmt_exc(e)}"
+        logger.error(msg)
+        raise BookalimoError(msg) from e
+
+
+def handle_autocomplete_impl(
+    transport_call: Callable[[dict[str, Any]], Any],
+    request: models.AutocompletePlacesRequest,
+) -> models.AutocompletePlacesResponse:
+    """Shared implementation for autocomplete method."""
+
+    proto = _call_gplaces_sync(
+        "Google Places Autocomplete", transport_call, request.model_dump()
+    )
+    return validate_proto_to_model(proto, models.AutocompletePlacesResponse)
+
+
+def prepare_geocode_params(
+    request: models.GeocodingRequest,
+    api_key: str,
+) -> Any:
+    """Prepare geocode parameters for both sync/async."""
+    params = request.to_query_params()
+    params = params.add("key", api_key)
+    return params
+
+
+def handle_geocode_response(response: Any) -> dict[str, Any]:
+    """Handle geocode response for both sync/async."""
+    try:
+        response.raise_for_status()
+        return cast(dict[str, Any], response.json())
+    except httpx.HTTPError as e:
+        msg = f"HTTP geocoding failed: {_fmt_exc(e)}"
+        logger.error(msg)
+        raise BookalimoError(msg) from e
+
+
+async def handle_autocomplete_impl_async(
+    transport_call: Callable[[dict[str, Any]], Awaitable[Any]],
+    request: models.AutocompletePlacesRequest,
+) -> models.AutocompletePlacesResponse:
+    """Shared implementation for async autocomplete method."""
+
+    proto = await _call_gplaces_async(
+        "Google Places Autocomplete", transport_call, request.model_dump()
+    )
+    return validate_proto_to_model(proto, models.AutocompletePlacesResponse)
+
+
+def handle_search_impl(
+    transport_call: Callable[[dict[str, Any], tuple[tuple[str, str], ...]], Any],
+    query: Optional[str] = None,
+    request: Optional[models.SearchTextRequest] = None,
+    fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
+    **kwargs: Any,
+) -> list[models.Place]:
+    """Shared implementation for search method."""
+    request_params, metadata = _prepare_search_params_and_metadata(
+        query, request, fields, **kwargs
+    )
+
+    protos = _call_gplaces_sync(
+        "Google Places Text Search", transport_call, request_params, metadata
+    )
+    return _normalize_search_results(protos)
+
+
+async def handle_search_impl_async(
+    transport_call: Callable[
+        [dict[str, Any], tuple[tuple[str, str], ...]], Awaitable[Any]
+    ],
+    query: Optional[str] = None,
+    request: Optional[models.SearchTextRequest] = None,
+    fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
+    **kwargs: Any,
+) -> list[models.Place]:
+    """Shared implementation for async search method."""
+    request_params, metadata = _prepare_search_params_and_metadata(
+        query, request, fields, **kwargs
+    )
+
+    protos = await _call_gplaces_async(
+        "Google Places Text Search", transport_call, request_params, metadata
+    )
+    return _normalize_search_results(protos)
+
+
+def handle_get_place_impl(
+    transport_call: Callable[[dict[str, Any], tuple[tuple[str, str], ...]], Any],
+    place_id: Optional[str] = None,
+    request: Optional[models.GetPlaceRequest] = None,
+    fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
+) -> Optional[models.Place]:
+    """Shared implementation for get place method."""
+    request_params, metadata = _prepare_get_params_and_metadata(
+        place_id, request, fields
+    )
+
+    proto = _call_gplaces_sync(
+        "Google Places Get Place",
+        transport_call,
+        request_params,
+        metadata,
+        not_found_ok=True,
+    )
+    return None if proto is None else _normalize_place_from_proto(proto)
+
+
+async def handle_get_place_impl_async(
+    transport_call: Callable[
+        [dict[str, Any], tuple[tuple[str, str], ...]], Awaitable[Any]
+    ],
+    place_id: Optional[str] = None,
+    request: Optional[models.GetPlaceRequest] = None,
+    fields: FieldMaskInput = DEFAULT_PLACE_FIELDS,
+) -> Optional[models.Place]:
+    """Shared implementation for async get place method."""
+    request_params, metadata = _prepare_get_params_and_metadata(
+        place_id, request, fields
+    )
+
+    proto = await _call_gplaces_async(
+        "Google Places Get Place",
+        transport_call,
+        request_params,
+        metadata,
+        not_found_ok=True,
+    )
+    return None if proto is None else _normalize_place_from_proto(proto)
+
+
+def _prepare_search_params_and_metadata(
+    query: Optional[str],
+    request: Optional[models.SearchTextRequest],
+    fields: FieldMaskInput,
+    **kwargs: Any,
+) -> tuple[dict[str, Any], tuple[tuple[str, str], ...]]:
+    """Prepare search parameters and metadata for both sync/async."""
+    request_params = _build_search_request_params(query, request, **kwargs)
+    metadata = _mask_header(fields, prefix="places")
+    return request_params, metadata
+
+
+def _prepare_get_params_and_metadata(
+    place_id: Optional[str],
+    request: Optional[models.GetPlaceRequest],
+    fields: FieldMaskInput,
+) -> tuple[dict[str, Any], tuple[tuple[str, str], ...]]:
+    """Prepare get place parameters and metadata for both sync/async."""
+    request_params = _build_get_place_request(place_id, request)
+    metadata = _mask_header(fields)
+    return request_params, metadata
+
+
+def create_search_text_request(
+    query: str,
+    region_code: Optional[str],
+) -> models.SearchTextRequest:
+    return models.SearchTextRequest(
+        text_query=query,
+        region_code=region_code,
+        max_result_count=5,
+        rank_preference=RankPreference.RELEVANCE,
+        # included_type="airport",
+        strict_type_filtering=False,
+    )
+
+
+def handle_resolve_airport_preprocessing(
+    query: Optional[str],
+    place_id: Optional[str],
+    places: Optional[list[models.Place]],
+    max_distance_km: Optional[float],
+) -> tuple[Optional[str], list[models.Place], bool]:
+    """
+    Handle the preprocessing logic for resolve_airport that doesn't depend on sync/async.
+    Returns (effective_query_or_none, places_to_resolve, needs_search_call).
+    If needs_search_call is True, the caller should perform a search using the query.
+    """
+    # Validate inputs
+    _validate_resolve_airport_inputs(place_id, places, max_distance_km)
+
+    # Handle different input scenarios
+    if place_id is not None:
+        # Caller needs to fetch the place using get()
+        return query, [], True  # Signal that caller needs to call get()
+
+    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."
+            )
+        return query, places, False
+
+    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.")
+        return query, [], True  # Signal that caller needs to call search()
+
+
+def handle_resolve_airport_postprocessing(
+    query: Optional[str],
+    effective_places: list[models.Place],
+    max_distance_km: Optional[float],
+    max_results: Optional[int],
+    confidence_threshold: Optional[float],
+    text_weight: float,
+) -> list[models.ResolvedAirport]:
+    """Handle the final processing logic for resolve_airport."""
+
+    # 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,
+        max_distance_km,
+        max_results,
+        confidence_threshold,
+        text_weight,
+    )