bookalimo 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

bookalimo/__init__.py

@@ -5,6 +5,7 @@ Provides a clean, typed interface to the Book-A-Limo API.
 
 import importlib.metadata
 
+from ._logging import disable_debug_logging, enable_debug_logging
 from .wrapper import (
     BookALimo,
     create_address_location,
@@ -23,6 +24,8 @@ __all__ = [
     "create_stop",
     "create_passenger",
     "create_credit_card",
+    "enable_debug_logging",
+    "disable_debug_logging",
 ]
 
 __version__ = importlib.metadata.version(__package__ or __name__)

bookalimo/_client.py

@@ -3,13 +3,17 @@ Base HTTP client for Book-A-Limo API.
 Handles authentication, headers, and common request/response patterns.
 """
 
+import logging
 from enum import Enum
 from functools import lru_cache
-from typing import Any, Optional, cast
+from time import perf_counter
+from typing import Any, Optional, TypeVar, cast, overload
+from uuid import uuid4
 
 import httpx
 from pydantic import BaseModel
 
+from ._logging import get_logger
 from .exceptions import BookALimoError
 from .models import (
     BookRequest,
@@ -29,6 +33,10 @@ from .models import (
     PriceResponse,
 )
 
+logger = get_logger("client")
+
+T = TypeVar("T")
+
 
 @lru_cache(maxsize=1)
 def get_version() -> str:
@@ -63,6 +71,13 @@ class BookALimoClient:
         }
         self.base_url = base_url
         self.http_timeout = http_timeout
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "Client initialized (base_url=%s, timeout=%s, user_agent=%s)",
+                self.base_url,
+                self.http_timeout,
+                self.headers.get("user-agent"),
+            )
 
     def _convert_model_to_api_dict(self, data: dict[str, Any]) -> dict[str, Any]:
         """
@@ -128,6 +143,19 @@ class BookALimoClient:
 
         return converted
 
+    @overload
+    def handle_enums(self, obj: Enum) -> Any: ...
+    @overload
+    def handle_enums(self, obj: dict[str, Any]) -> dict[str, Any]: ...
+    @overload
+    def handle_enums(self, obj: list[Any]) -> list[Any]: ...
+    @overload
+    def handle_enums(self, obj: tuple[Any, ...]) -> tuple[Any, ...]: ...
+    @overload
+    def handle_enums(self, obj: set[Any]) -> set[Any]: ...
+    @overload
+    def handle_enums(self, obj: Any) -> Any: ...
+
     def handle_enums(self, obj: Any) -> Any:
         """
         Simple utility to convert enums to their values for JSON serialization.
@@ -158,6 +186,21 @@ class BookALimoClient:
             result.append(char.lower())
         return "".join(result)
 
+    def prepare_data(self, data: BaseModel) -> dict[str, Any]:
+        """
+        Prepare data for API requests by converting it to the appropriate format.
+
+        Args:
+            data: The data to prepare, as a Pydantic model instance.
+
+        Returns:
+            A dictionary representation of the data, ready for API consumption.
+        """
+        api_data = self._convert_model_to_api_dict(data.model_dump())
+        api_data = self._remove_none_values(api_data)
+        api_data = self.handle_enums(api_data)
+        return cast(dict[str, Any], api_data)
+
     async def _make_request(
         self,
         endpoint: str,
@@ -165,29 +208,24 @@ class BookALimoClient:
         model: type[BaseModel],
         timeout: Optional[float] = None,
     ) -> BaseModel:
-        """
-        Make a POST request to the API with proper error handling.
-
-        Args:
-            endpoint: API endpoint (e.g., "/booking/reservation/list/")
-            data: Request payload as dict or Pydantic model
-            model: Pydantic model to parse the response into
-            timeout: Request timeout in seconds
-
-        Returns:
-            Parsed JSON response as pydantic model
-
-        Raises:
-            BookALimoError: On API errors or HTTP errors
-        """
         url = f"{self.base_url}{endpoint}"
 
         # Convert model data to API format
-        api_data = self._convert_model_to_api_dict(data.model_dump())
-
-        # Remove None values to avoid API issues
-        api_data = self._remove_none_values(api_data)
-        api_data = self.handle_enums(api_data)
+        api_data = self.prepare_data(data)
+
+        debug_on = logger.isEnabledFor(logging.DEBUG)
+        req_id = None
+        if debug_on:
+            req_id = uuid4().hex[:8]
+            start = perf_counter()
+            body_keys = sorted(k for k in api_data.keys() if k != "credentials")
+            logger.debug(
+                "→ [%s] POST %s timeout=%s body_keys=%s",
+                req_id,
+                endpoint,
+                timeout or self.http_timeout,
+                body_keys,
+            )
 
         try:
             response = await self.client.post(
@@ -198,11 +236,13 @@ class BookALimoClient:
             )
             response.raise_for_status()
 
-            # Handle different HTTP status codes
+            # HTTP 4xx/5xx already raise in httpx, but keep defensive check:
             if response.status_code >= 400:
-                error_msg = f"HTTP {response.status_code}: {response.text}"
+                error_msg = f"HTTP {response.status_code}"
+                if debug_on:
+                    logger.warning("× [%s] %s %s", req_id or "-", endpoint, error_msg)
                 raise BookALimoError(
-                    error_msg,
+                    f"{error_msg}: {response.text}",
                     status_code=response.status_code,
                     response_data={"raw_response": response.text},
                 )
@@ -210,41 +250,92 @@ class BookALimoClient:
             try:
                 json_data = response.json()
             except ValueError as e:
+                if debug_on:
+                    logger.warning("× [%s] %s invalid JSON", req_id or "-", endpoint)
                 raise BookALimoError(f"Invalid JSON response: {str(e)}") from e
 
-            # Check for API-level errors
+            # API-level errors
             if isinstance(json_data, dict):
-                if "error" in json_data and json_data["error"]:
+                if json_data.get("error"):
+                    if debug_on:
+                        logger.warning("× [%s] %s API error", req_id or "-", endpoint)
                     raise BookALimoError(
                         f"API Error: {json_data['error']}", response_data=json_data
                     )
-
-                # Check success flag if present
                 if "success" in json_data and not json_data["success"]:
-                    error_msg = json_data.get("error", "Unknown API error")
-                    raise BookALimoError(
-                        f"API Error: {error_msg}", response_data=json_data
-                    )
+                    msg = json_data.get("error", "Unknown API error")
+                    if debug_on:
+                        logger.warning("× [%s] %s API error", req_id or "-", endpoint)
+                    raise BookALimoError(f"API Error: {msg}", response_data=json_data)
+
+            if debug_on:
+                dur_ms = (perf_counter() - start) * 1000.0
+                reqid_hdr = response.headers.get(
+                    "x-request-id"
+                ) or response.headers.get("request-id")
+                content_len = None
+                try:
+                    content_len = len(response.content)
+                except Exception:
+                    pass
+                logger.debug(
+                    "← [%s] %s %s in %.1f ms len=%s reqid=%s",
+                    req_id,
+                    response.status_code,
+                    endpoint,
+                    dur_ms,
+                    content_len,
+                    reqid_hdr,
+                )
 
-            # Convert response back to model format
             return model.model_validate(self._convert_api_to_model_dict(json_data))
 
         except httpx.TimeoutException:
+            if debug_on:
+                logger.warning(
+                    "× [%s] %s timeout after %ss",
+                    req_id or "-",
+                    endpoint,
+                    timeout or self.http_timeout,
+                )
             raise BookALimoError(
                 f"Request timeout after {timeout or self.http_timeout}s"
             ) from None
         except httpx.ConnectError:
+            if debug_on:
+                logger.warning("× [%s] %s connection error", req_id or "-", endpoint)
             raise BookALimoError(
                 "Connection error - unable to reach Book-A-Limo API"
             ) from None
         except httpx.HTTPError as e:
+            if debug_on:
+                logger.warning(
+                    "× [%s] %s HTTP error: %s",
+                    req_id or "-",
+                    endpoint,
+                    e.__class__.__name__,
+                )
             raise BookALimoError(f"HTTP Error: {str(e)}") from e
         except BookALimoError:
-            # Re-raise our custom errors
+            # already logged above where relevant
             raise
         except Exception as e:
+            if debug_on:
+                logger.warning(
+                    "× [%s] %s unexpected error: %s",
+                    req_id or "-",
+                    endpoint,
+                    e.__class__.__name__,
+                )
             raise BookALimoError(f"Unexpected error: {str(e)}") from e
 
+    @overload
+    def _remove_none_values(self, data: dict[str, Any]) -> dict[str, Any]: ...
+    @overload
+    def _remove_none_values(self, data: list[Any]) -> list[Any]: ...
+    @overload
+    def _remove_none_values(self, data: Any) -> Any: ...
+
     def _remove_none_values(self, data: Any) -> Any:
         """Recursively remove None values from data structure."""
         if isinstance(data, dict):

bookalimo/_logging.py

@@ -0,0 +1,244 @@
+"""
+Logging configuration for bookalimo package.
+Public SDK-style logging with built-in redaction helpers.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from collections.abc import Iterable, Mapping
+from time import perf_counter
+from typing import Any, Callable
+
+logger = logging.getLogger("bookalimo")
+logger.addHandler(logging.NullHandler())
+logger.setLevel(logging.WARNING)
+
+REDACTED = "******"
+
+
+def mask_token(s: Any, *, show_prefix: int = 6, show_suffix: int = 2) -> str:
+    if not isinstance(s, str) or not s:
+        return REDACTED
+    if len(s) <= show_prefix + show_suffix:
+        return REDACTED
+    return f"{s[:show_prefix]}…{s[-show_suffix:]}"
+
+
+def mask_email(s: Any) -> str:
+    if not isinstance(s, str) or "@" not in s:
+        return REDACTED
+    name, domain = s.split("@", 1)
+    return f"{name[:1]}***@{domain}"
+
+
+def mask_phone(s: Any) -> str:
+    if not isinstance(s, str):
+        return REDACTED
+    digits = re.sub(r"\D", "", s)
+    tail = digits[-4:] if digits else ""
+    return f"***-***-{tail}" if tail else REDACTED
+
+
+def mask_card_number(s: Any) -> str:
+    if not isinstance(s, str) or len(s) < 4:
+        return REDACTED
+    return f"**** **** **** {s[-4:]}"
+
+
+def _safe_str(x: Any) -> str:
+    # Avoid large/complex reprs when logging
+    try:
+        s = str(x)
+    except Exception:
+        s = object.__repr__(x)
+    # hard scrub for obvious long tokens
+    if len(s) > 256:
+        return s[:256] + "…"
+    return s
+
+
+def summarize_card(card: Any) -> dict[str, Any]:
+    """
+    Produce a tiny, safe card summary from either a mapping or an object with attributes.
+    """
+
+    def get(obj: Any, key: str) -> Any:
+        if isinstance(obj, Mapping):
+            return obj.get(key)
+        return getattr(obj, key, None)
+
+    number = get(card, "number")
+    exp = get(card, "expiration")
+    holder_type = get(card, "holder_type")
+    zip_code = get(card, "zip") or get(card, "zip_code")
+
+    return {
+        "last4": number[-4:] if isinstance(number, str) and len(number) >= 4 else None,
+        "expiration": REDACTED if exp else None,
+        "holder_type": str(holder_type) if holder_type is not None else None,
+        "zip_present": bool(zip_code),
+    }
+
+
+def summarize_mapping(
+    data: Mapping[str, Any], *, whitelist: Iterable[str] | None = None
+) -> dict[str, Any]:
+    """
+    Keep only whitelisted keys; for everything else just show presence (True/False).
+    Avoids logging raw contents of complex payloads.
+    """
+    out: dict[str, Any] = {}
+    allowed = set(whitelist or [])
+    for k, v in data.items():
+        if k in allowed:
+            out[k] = v
+        else:
+            out[k] = bool(v)  # presence only
+    return out
+
+
+def redact_param(name: str, value: Any) -> Any:
+    key = name.lower()
+    if key in {"password", "password_hash"}:
+        return REDACTED
+    if key in {"token", "authorization", "authorization_bearer", "api_key", "secret"}:
+        return mask_token(value)
+    if key in {"email"}:
+        return mask_email(value)
+    if key in {"phone"}:
+        return mask_phone(value)
+    if key in {"cvv", "cvc", "promo"}:
+        return REDACTED
+    if key in {"number", "card_number"}:
+        return mask_card_number(value)
+    if key in {"credit_card", "card"}:
+        return summarize_card(value)
+    if key in {"zip", "zipcode", "postal_code"}:
+        return REDACTED
+    if isinstance(value, (str, int, float, bool, type(None))):
+        return value
+    return _safe_str(value)
+
+
+# ---- public API --------------------------------------------------------------
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    if name:
+        return logging.getLogger(f"bookalimo.{name}")
+    return logger
+
+
+def enable_debug_logging(level: int | None = None) -> None:
+    level = level or _level_from_env() or logging.DEBUG
+    logger.setLevel(level)
+
+    has_real_handler = any(
+        not isinstance(h, logging.NullHandler) for h in logger.handlers
+    )
+    if not has_real_handler:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    logger.info("bookalimo logging enabled at %s", logging.getLevelName(logger.level))
+
+
+def disable_debug_logging() -> None:
+    logger.setLevel(logging.WARNING)
+    for handler in logger.handlers[:]:
+        if not isinstance(handler, logging.NullHandler):
+            logger.removeHandler(handler)
+
+
+def _level_from_env() -> int | None:
+    lvl = os.getenv("BOOKALIMO_LOG_LEVEL")
+    if not lvl:
+        return None
+    try:
+        return int(lvl)
+    except ValueError:
+        try:
+            return logging._nameToLevel.get(lvl.upper(), None)
+        except Exception:
+            return None
+
+
+# ---- decorator for async methods --------------------------------------------
+
+
+def log_call(
+    *,
+    include_params: Iterable[str] | None = None,
+    transforms: Mapping[str, Callable[[Any], Any]] | None = None,
+    operation: str | None = None,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """
+    Decorator for async SDK methods.
+    - DEBUG: logs start/end with sanitized params + duration
+    - WARNING: logs errors (sanitized). No overhead when DEBUG is off.
+    """
+    include = set(include_params or [])
+    transforms = transforms or {}
+
+    def _decorate(fn: Callable[..., Any]) -> Callable[..., Any]:
+        async def _async_wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+            log = get_logger("wrapper")
+            op = operation or fn.__name__
+
+            # Fast path: if debug disabled, skip param binding/redaction entirely
+            debug_on = log.isEnabledFor(logging.DEBUG)
+            if debug_on:
+                # Build a minimal, sanitized args snapshot
+                snapshot: dict[str, Any] = {}
+                # Map positional args to param names without inspect overhead by relying on kwargs only:
+                # we assume call sites are using kwargs in the wrapper (they do).
+                for k in include:
+                    val = kwargs.get(k, None)
+                    if k in transforms:
+                        try:
+                            val = transforms[k](val)
+                        except Exception:
+                            val = REDACTED
+                    else:
+                        val = redact_param(k, val)
+                    snapshot[k] = val
+
+                start = perf_counter()
+                log.debug(
+                    "→ %s(%s)",
+                    op,
+                    ", ".join(f"{k}={snapshot[k]}" for k in snapshot),
+                    extra={"operation": op},
+                )
+
+            try:
+                result = await fn(self, *args, **kwargs)
+                if debug_on:
+                    dur_ms = (perf_counter() - start) * 1000.0
+                    # Keep result logging ultra-light
+                    result_type = type(result).__name__
+                    log.debug(
+                        "← %s ok in %.1f ms (%s)",
+                        op,
+                        dur_ms,
+                        result_type,
+                        extra={"operation": op},
+                    )
+                return result
+            except Exception as e:
+                # WARNING with sanitized error; no param dump on failures
+                log.warning(
+                    "%s failed: %s", op, e.__class__.__name__, extra={"operation": op}
+                )
+                raise
+
+        return _async_wrapper
+
+    return _decorate

bookalimo/wrapper.py

@@ -3,12 +3,14 @@ High-level API wrapper for Book-A-Limo operations.
 Provides clean, LLM-friendly functions that abstract API complexities.
 """
 
+import logging
 from types import TracebackType
 from typing import Any, Optional
 
 from httpx import AsyncClient
 
 from ._client import BookALimoClient
+from ._logging import get_logger, log_call
 from .exceptions import BookALimoError
 from .models import (
     Address,
@@ -34,6 +36,8 @@ from .models import (
     Stop,
 )
 
+logger = get_logger("wrapper")
+
 
 class BookALimo:
     """
@@ -45,7 +49,7 @@ class BookALimo:
         self,
         credentials: Credentials,
         http_client: Optional[AsyncClient] = None,
-        base_url: str = "https://api.bookalimo.com",
+        base_url: str = "https://www.bookalimo.com/web/api",
         http_timeout: float = 5.0,
         **kwargs: Any,
     ):
@@ -66,11 +70,20 @@ class BookALimo:
             http_timeout=http_timeout,
             **kwargs,
         )
+        if logger.isEnabledFor(logging.DEBUG):  # NEW: tiny, safe init log
+            logger.debug(
+                "BookALimo initialized (base_url=%s, timeout=%s, owns_http_client=%s)",
+                base_url,
+                http_timeout,
+                self._owns_http_client,
+            )
 
     async def aclose(self) -> None:
         """Close the HTTP client if we own it."""
         if self._owns_http_client and not self.http_client.is_closed:
             await self.http_client.aclose()
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug("HTTP client closed")
 
     async def __aenter__(self) -> "BookALimo":
         """Async context manager entry."""
@@ -85,6 +98,7 @@ class BookALimo:
         """Async context manager exit."""
         await self.aclose()
 
+    @log_call(include_params=["is_archive"], operation="list_reservations")
     async def list_reservations(
         self, is_archive: bool = False
     ) -> ListReservationsResponse:
@@ -104,6 +118,7 @@ class BookALimo:
         except Exception as e:
             raise BookALimoError(f"Failed to list reservations: {str(e)}") from e
 
+    @log_call(include_params=["confirmation"], operation="get_reservation")
     async def get_reservation(self, confirmation: str) -> GetReservationResponse:
         """
         Get detailed reservation information.
@@ -121,6 +136,15 @@ class BookALimo:
         except Exception as e:
             raise BookALimoError(f"Failed to get reservation: {str(e)}") from e
 
+    @log_call(
+        include_params=[
+            "rate_type",
+            "date_time",
+            "passengers",
+            "luggage",
+        ],
+        operation="get_prices",
+    )
     async def get_prices(
         self,
         rate_type: RateType,
@@ -137,8 +161,8 @@ class BookALimo:
         Args:
             rate_type: 0=P2P, 1=Hourly (or string names)
             date_time: 'MM/dd/yyyy hh:mm tt' format
-            pickup_location: Location dict
-            dropoff_location: Location dict
+            pickup_location: Location
+            dropoff_location: Location
             passengers: Number of passengers
             luggage: Number of luggage pieces
             **kwargs: Optional fields like stops, account, car_class_code, etc.
@@ -184,6 +208,15 @@ class BookALimo:
         except Exception as e:
             raise BookALimoError(f"Failed to get prices: {str(e)}") from e
 
+    @log_call(
+        include_params=["token", "details"],
+        transforms={
+            "details": lambda d: sorted(
+                [k for k, v in (d or {}).items() if v is not None]
+            ),
+        },
+        operation="set_details",
+    )
     async def set_details(self, token: str, **details: Any) -> DetailsResponse:
         """
         Set reservation details and get updated pricing.
@@ -213,6 +246,10 @@ class BookALimo:
         except Exception as e:
             raise BookALimoError(f"Failed to set details: {str(e)}") from e
 
+    @log_call(
+        include_params=["token", "method", "promo", "credit_card"],
+        operation="book",
+    )
     async def book(
         self,
         token: str,
@@ -255,6 +292,15 @@ class BookALimo:
         except Exception as e:
             raise BookALimoError(f"Failed to book reservation: {str(e)}") from e
 
+    @log_call(
+        include_params=["confirmation", "is_cancel_request", "changes"],
+        transforms={
+            "changes": lambda d: sorted(
+                [k for k, v in (d or {}).items() if v is not None]
+            ),
+        },
+        operation="edit_reservation",
+    )
     async def edit_reservation(
         self, confirmation: str, is_cancel_request: bool = False, **changes: Any
     ) -> EditReservationResponse:

{bookalimo-0.1.3.dist-info → bookalimo-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bookalimo
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python wrapper for the Book-A-Limo API
 Author-email: Jonathan Oren <jonathan@bookalimo.com>
 Maintainer-email: Jonathan Oren <jonathan@bookalimo.com>
@@ -65,6 +65,36 @@ Dynamic: license-file
 
 A modern, async Python wrapper for the Book-A-Limo API with full type support. Built on top of `httpx` and `pydantic`.
 
+## Table of Contents
+
+- [Book-A-Limo Python SDK](#book-a-limo-python-sdk)
+  - [Table of Contents](#table-of-contents)
+  - [Features](#features)
+  - [Requirements](#requirements)
+  - [Installation](#installation)
+  - [Quick Start](#quick-start)
+  - [Authentication](#authentication)
+  - [Core Operations](#core-operations)
+    - [Get Pricing](#get-pricing)
+    - [Book a Reservation](#book-a-reservation)
+  - [Location Builders](#location-builders)
+    - [Airport Locations](#airport-locations)
+    - [Address Locations](#address-locations)
+    - [Stops](#stops)
+  - [Advanced](#advanced)
+    - [Using Account Info (Travel Agents)](#using-account-info-travel-agents)
+    - [Edit / Cancel a Reservation](#edit--cancel-a-reservation)
+  - [Error Handling](#error-handling)
+  - [Logging](#logging)
+    - [Enable Debug Logging](#enable-debug-logging)
+    - [Custom Logging](#custom-logging)
+    - [Security](#security)
+    - [Disable Logging](#disable-logging)
+  - [Development](#development)
+  - [Security Notes](#security-notes)
+  - [License](#license)
+  - [Changelog](#changelog)
+
 ## Features
 
 * **Asynchronous**
@@ -90,7 +120,6 @@ pip install bookalimo
 
 ```python
 import asyncio
-from httpx import AsyncClient
 
 from bookalimo import (
     BookALimo,
@@ -98,7 +127,7 @@ from bookalimo import (
     create_airport_location,
     create_address_location,
 )
-from bookalimo.models import RateType  # enums/models come from bookalimo.models
+from bookalimo.models import RateType
 
 async def main():
     # For Travel Agents (customers: pass is_customer=True)
@@ -288,6 +317,50 @@ except BookALimoError as e:
     print(f"Response Data: {e.response_data}")
 ```
 
+## Logging
+
+By default, no log messages appear. Enable logging for debugging or monitoring.
+
+### Enable Debug Logging
+
+```python
+import bookalimo
+
+bookalimo.enable_debug_logging()
+
+async with bookalimo.BookALimo(credentials) as client:
+    reservations = await client.list_reservations()  # Shows API calls, timing, etc.
+```
+
+Or use the environment variable:
+```bash
+export BOOKALIMO_LOG_LEVEL=DEBUG
+```
+
+### Custom Logging
+
+```python
+import logging
+import bookalimo
+
+logging.basicConfig(level=logging.INFO)
+bookalimo.get_logger().setLevel(logging.WARNING)  # Production setting
+```
+
+### Security
+
+Sensitive data is automatically redacted in logs:
+- Passwords, tokens, CVV codes: `******`
+- API keys: `abc123…89` (first 6, last 2 chars)
+- Emails: `j***@example.com`
+- Credit cards: `**** **** **** 1234`
+
+### Disable Logging
+
+```python
+bookalimo.disable_debug_logging()
+```
+
 ## Development
 
 ```bash

bookalimo-0.1.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+bookalimo/__init__.py,sha256=rzbMBdkp0hIIQJ8AVLHeA6y4YrNIezfzUxP2iNcRBaw,691
+bookalimo/_client.py,sha256=-kpaWBeEwFcXL28he0zFpx557jcZTUcx_NTjraSHSPQ,14537
+bookalimo/_logging.py,sha256=frnwQtx9FTADPa0r38A1y7j-1VLBgGJ1p6dod_g0n6k,7646
+bookalimo/exceptions.py,sha256=ubOUZiXGEOWZvXyz2D5f5zwxBlQZVDBv1uOPmokAQ6Q,404
+bookalimo/models.py,sha256=-gvxrT7llrYLxSHWn3vpmvkQqnk2ejSd97Sw8BxgBLw,16420
+bookalimo/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+bookalimo/wrapper.py,sha256=tusu2D4CkQqI7VKxSh62bK9hvleNHjuGD_6EpsWi2xg,13381
+bookalimo-0.1.4.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bookalimo-0.1.4.dist-info/METADATA,sha256=f_kTmUYU_MhJJNXhienHzlSDEo4M8IVw0Tcc4WyGkfQ,10739
+bookalimo-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bookalimo-0.1.4.dist-info/top_level.txt,sha256=ZgYiDX2GfZCp4pevWn4X2qyEr-Dh7-cq5Y1j2jMhB1s,10
+bookalimo-0.1.4.dist-info/RECORD,,

bookalimo-0.1.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-bookalimo/__init__.py,sha256=ch1t7uvw_F3zNpqb-IfH0n2sDwFLnAQDgm2lpwtvpj4,568
-bookalimo/_client.py,sha256=vju39534nm-6TVBZ7H74VTZIKdYOAnQiN1nFUqifRTM,11166
-bookalimo/exceptions.py,sha256=ubOUZiXGEOWZvXyz2D5f5zwxBlQZVDBv1uOPmokAQ6Q,404
-bookalimo/models.py,sha256=-gvxrT7llrYLxSHWn3vpmvkQqnk2ejSd97Sw8BxgBLw,16420
-bookalimo/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
-bookalimo/wrapper.py,sha256=tlhfGR6jQqnx33GO6d3fQZ8a5294UkftC1ORcvbhDww,11896
-bookalimo-0.1.3.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bookalimo-0.1.3.dist-info/METADATA,sha256=9CXiMDcKrhLe_2pHpVlYA7UTo8twYGmMOsl933V4vXo,8857
-bookalimo-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bookalimo-0.1.3.dist-info/top_level.txt,sha256=ZgYiDX2GfZCp4pevWn4X2qyEr-Dh7-cq5Y1j2jMhB1s,10
-bookalimo-0.1.3.dist-info/RECORD,,