lago-python-client 1.46.0__tar.gz → 1.48.0__tar.gz

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lago-python-client
-Version: 1.46.0
+Version: 1.48.0
 Summary: Lago Python API Client
 Home-page: https://github.com/getlago/lago-python-client
 Author: Lovro Colic

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/client.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from urllib.parse import urljoin
 
 from .activity_logs.clients import ActivityLogClient
@@ -32,7 +33,7 @@ from .payments.clients import PaymentClient
 from .plans.charges_client import PlanChargesClient
 from .plans.clients import PlanClient
 from .plans.fixed_charges_client import PlanFixedChargesClient
-from .services.rate_limit import RateLimitRetryConfig
+from .services.rate_limit import RateLimitCallback, RateLimitRetryConfig
 from .subscriptions.charges_client import SubscriptionChargesClient
 from .subscriptions.clients import SubscriptionClient
 from .subscriptions.fixed_charges_client import SubscriptionFixedChargesClient
@@ -61,6 +62,7 @@ class Client:
         ingest_api_url: str = "",
         max_retries: int = 3,
         retry_on_rate_limit: bool = True,
+        on_rate_limit_info: Optional[RateLimitCallback] = None,
     ) -> None:
         self.api_key: str = api_key
         self.api_url: str = api_url
@@ -69,6 +71,7 @@ class Client:
         self.rate_limit_retry_config: RateLimitRetryConfig = RateLimitRetryConfig(
             max_retries=max_retries,
             retry_on_rate_limit=retry_on_rate_limit,
+            on_rate_limit_info=on_rate_limit_info,
         )
 
     @property

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/customers/clients.py

@@ -1,4 +1,5 @@
 import json
+import warnings
 from collections.abc import Mapping
 from typing import Any, ClassVar, Optional, Type, Union
 
@@ -46,17 +47,42 @@ class CustomerClient(
         filter_by_charge_id: Optional[str] = None,
         filter_by_charge_code: Optional[str] = None,
         filter_by_group: Optional[dict] = None,
+        filter_by_presentation: Optional[Union[str, list[str]]] = None,
         full_usage: Optional[bool] = None,
+        charge_id: Optional[str] = None,
+        charge_code: Optional[str] = None,
+        billable_metric_code: Optional[str] = None,
+        group: Optional[dict] = None,
     ) -> CustomerUsageResponse:
         query_params: dict[str, Union[str, bool]] = {"external_subscription_id": external_subscription_id}
         if apply_taxes is not None:
             query_params["apply_taxes"] = apply_taxes
+        if charge_id is not None:
+            query_params["charge_id"] = charge_id
+        if charge_code is not None:
+            query_params["charge_code"] = charge_code
+        if billable_metric_code is not None:
+            query_params["billable_metric_code"] = billable_metric_code
+        if group is not None:
+            for k, v in group.items():
+                query_params[f"group[{k}]"] = v
         if filter_by_charge_id is not None:
+            warnings.warn("filter_by_charge_id is deprecated, use charge_id instead", DeprecationWarning, stacklevel=2)
             query_params["filter_by_charge_id"] = filter_by_charge_id
         if filter_by_charge_code is not None:
+            warnings.warn(
+                "filter_by_charge_code is deprecated, use charge_code instead", DeprecationWarning, stacklevel=2
+            )
             query_params["filter_by_charge_code"] = filter_by_charge_code
         if filter_by_group is not None:
+            warnings.warn("filter_by_group is deprecated, use group instead", DeprecationWarning, stacklevel=2)
             query_params["filter_by_group"] = json.dumps(filter_by_group)
+        if filter_by_presentation is not None:
+            query_params["filter_by_presentation"] = (
+                filter_by_presentation
+                if isinstance(filter_by_presentation, str)
+                else json.dumps(filter_by_presentation)
+            )
         if full_usage is not None:
             query_params["full_usage"] = str(full_usage).lower()
 

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/__init__.py

@@ -138,6 +138,12 @@ from .customer_usage import (
 from .customer_usage import (
     Metric as Metric,
 )
+from .customer_usage import (
+    PresentationBreakdown as PresentationBreakdown,
+)
+from .customer_usage import (
+    PresentationBreakdowns as PresentationBreakdowns,
+)
 from .event import BatchEvent as BatchEvent
 from .event import Event as Event
 from .fee import Fee as Fee

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/customer_projected_usage.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Optional
 from lago_python_client.base_model import BaseModel
 
 from ..base_model import BaseResponseModel
+from .customer_usage import PresentationBreakdowns
 
 
 class Metric(BaseModel):
@@ -27,6 +28,8 @@ class ProjectedChargeFilterUsage(BaseModel):
     projected_amount_cents: int
     events_count: int
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
+    projected_presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class ChargeObject(BaseModel):
@@ -44,6 +47,8 @@ class ProjectedGroupedUsage(BaseModel):
     grouped_by: Dict[str, Optional[str]]
     filters: List[ProjectedChargeFilterUsage]
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
+    projected_presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class ProjectedChargeUsage(BaseModel):
@@ -58,6 +63,8 @@ class ProjectedChargeUsage(BaseModel):
     filters: List[ProjectedChargeFilterUsage]
     grouped_usage: Optional[List[ProjectedGroupedUsage]]
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
+    projected_presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class CustomerProjectedUsageResponse(BaseResponseModel):

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/customer_usage.py

@@ -18,6 +18,15 @@ class PricingUnitDetails(BaseModel):
     conversion_rate: float
 
 
+class PresentationBreakdown(BaseModel):
+    presentation_by: Dict[str, str]
+    units: str
+
+
+class PresentationBreakdowns(BaseModel):
+    __root__: List[PresentationBreakdown]
+
+
 class ChargeFilterUsage(BaseModel):
     invoice_display_name: Optional[str]
     values: Optional[Dict[str, List[str]]]
@@ -26,6 +35,7 @@ class ChargeFilterUsage(BaseModel):
     amount_cents: int
     events_count: int
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class ChargeObject(BaseModel):
@@ -42,6 +52,7 @@ class GroupedUsage(BaseModel):
     grouped_by: Dict[str, Optional[str]]
     filters: List[ChargeFilterUsage]
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class ChargeUsage(BaseModel):
@@ -55,6 +66,7 @@ class ChargeUsage(BaseModel):
     filters: List[ChargeFilterUsage]
     grouped_usage: Optional[List[GroupedUsage]]
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
 
 
 class CustomerUsageResponse(BaseResponseModel):

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/fee.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, List, Optional
 
 from ..base_model import BaseModel, BaseResponseModel
+from .customer_usage import PresentationBreakdowns
 from .invoice_item import InvoiceItemResponse
 
 
@@ -75,6 +76,7 @@ class FeeResponse(BaseResponseModel):
     to_date: Optional[str]
     amount_details: Optional[Dict[str, Any]]
     pricing_unit_details: Optional[PricingUnitDetails]
+    presentation_breakdowns: Optional[PresentationBreakdowns]
     billing_entity_code: Optional[str]
 
     item: Optional[InvoiceItemResponse]

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/organization.py

@@ -56,3 +56,4 @@ class OrganizationResponse(BaseResponseModel):
     email_settings: Optional[List[str]]
     finalize_zero_amount_invoice: Optional[bool]
     billing_configuration: Optional[OrganizationBillingConfiguration]
+    events_store: Optional[str]

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/models/subscription.py

@@ -19,6 +19,7 @@ class Subscription(BaseModel):
     plan_overrides: Optional[PlanOverrides]
     payment_method: Optional[PaymentMethod]
     invoice_custom_section: Optional[InvoiceCustomSectionInput]
+    consolidate_invoice: Optional[bool]
 
 
 class Subscriptions(BaseModel):
@@ -55,6 +56,7 @@ class SubscriptionResponse(BaseResponseModel):
     on_termination_invoice: Optional[str]
     payment_method: Optional[PaymentMethod]
     applied_invoice_custom_sections: Optional[AppliedInvoiceCustomSections]
+    consolidate_invoice: Optional[bool]
 
 
 class SubscriptionsResponse(BaseResponseModel):

lago_python_client-1.48.0/lago_python_client/observability.py

@@ -0,0 +1,67 @@
+"""
+Optional observability helpers for Lago rate limits.
+
+Provides ready-to-use ``on_rate_limit_info`` callbacks so callers can opt into
+rate limit observability without writing one themselves.
+
+Example:
+    from lago_python_client import Client
+    from lago_python_client.observability import LoggingRateLimitObserver
+
+    client = Client(
+        api_key="...",
+        on_rate_limit_info=LoggingRateLimitObserver(),
+    )
+"""
+
+import logging
+from typing import Optional, Sequence
+
+from .services.rate_limit import RateLimitInfo
+
+DEFAULT_THRESHOLDS: Sequence[float] = (0.80, 0.90, 0.95)
+
+
+class LoggingRateLimitObserver:
+    """
+    Emits a log line each time rate limit usage crosses a configured threshold.
+
+    Stateless across calls: every response that lands above any threshold logs.
+    If you want one-shot crossings, wrap it with your own state.
+
+    Args:
+        thresholds: Usage fractions (0.0 - 1.0) that should produce a log line.
+            Defaults to 80%, 90%, 95%.
+        logger: Logger to emit on. Defaults to ``lago_python_client.rate_limit``.
+        level: Log level used when a threshold is crossed. Defaults to WARNING.
+    """
+
+    def __init__(
+        self,
+        thresholds: Sequence[float] = DEFAULT_THRESHOLDS,
+        logger: Optional[logging.Logger] = None,
+        level: int = logging.WARNING,
+    ) -> None:
+        # Sort descending so we report the highest matching threshold first.
+        self.thresholds = tuple(sorted(thresholds, reverse=True))
+        self.logger = logger or logging.getLogger("lago_python_client.rate_limit")
+        self.level = level
+
+    def __call__(self, info: RateLimitInfo) -> None:
+        pct = info.usage_pct
+        if pct is None:
+            return
+
+        for threshold in self.thresholds:
+            if pct >= threshold:
+                self.logger.log(
+                    self.level,
+                    "Lago rate limit at %.0f%% (limit=%s, remaining=%s, reset=%ss, %s %s)",
+                    pct * 100,
+                    info.limit,
+                    info.remaining,
+                    info.reset,
+                    info.method,
+                    info.url,
+                )
+                return

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/services/rate_limit.py

@@ -1,11 +1,87 @@
+import logging
 import time
-from typing import TYPE_CHECKING, Optional
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
     from httpx import Response
 
 from ..exceptions import LagoRateLimitError
 
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class RateLimitInfo:
+    """
+    Parsed rate limit headers from a Lago API response.
+
+    Provided to ``on_rate_limit_info`` callbacks after every successful request
+    so callers can build their own observability (metrics, logs, alerts).
+    """
+
+    limit: Optional[int]
+    remaining: Optional[int]
+    reset: Optional[int]
+    url: str
+    method: str
+
+    @property
+    def usage_pct(self) -> Optional[float]:
+        """
+        Fraction of the rate limit currently used, between 0.0 and 1.0.
+
+        Returns None when the headers aren't usable (missing, zero limit, etc.).
+        """
+        if self.limit is None or self.remaining is None or self.limit <= 0:
+            return None
+        return 1.0 - (self.remaining / self.limit)
+
+
+RateLimitCallback = Callable[[RateLimitInfo], None]
+
+
+def parse_rate_limit_info(
+    response: "Response",
+    method: str,
+    url: str,
+) -> Optional[RateLimitInfo]:
+    """
+    Parse ``x-ratelimit-*`` headers from a response into a RateLimitInfo.
+
+    Returns ``None`` when no rate limit headers are present (for example, on a
+    self-hosted Lago instance that doesn't enforce limits) so callers can skip
+    emission entirely.
+    """
+    headers = response.headers
+    limit: Optional[int] = None
+    remaining: Optional[int] = None
+    reset: Optional[int] = None
+
+    try:
+        limit = int(headers["x-ratelimit-limit"])
+    except (KeyError, ValueError, TypeError):
+        pass
+    try:
+        remaining = int(headers["x-ratelimit-remaining"])
+    except (KeyError, ValueError, TypeError):
+        pass
+    try:
+        reset = int(headers["x-ratelimit-reset"])
+    except (KeyError, ValueError, TypeError):
+        pass
+
+    if limit is None and remaining is None and reset is None:
+        return None
+
+    return RateLimitInfo(
+        limit=limit,
+        remaining=remaining,
+        reset=reset,
+        url=url,
+        method=method,
+    )
+
 
 class RateLimitRetryConfig:
     """Configuration for rate limit retry behavior."""
@@ -17,6 +93,7 @@ class RateLimitRetryConfig:
         base_backoff_seconds: float = 1.0,
         backoff_multiplier: float = 2.0,
         max_retry_delay: float = 20.0,
+        on_rate_limit_info: Optional[RateLimitCallback] = None,
     ):
         """
         Initialize rate limit retry configuration.
@@ -27,12 +104,18 @@ class RateLimitRetryConfig:
             base_backoff_seconds: Initial backoff duration in seconds for exponential backoff.
             backoff_multiplier: Multiplier for exponential backoff between retries.
             max_retry_delay: Maximum delay in seconds before a retry (default: 20).
+            on_rate_limit_info: Optional callback invoked after every successful
+                response with parsed rate limit headers. Use this to build
+                observability around the rate limit (warn at 80%, emit metrics,
+                etc.). Exceptions raised from the callback are logged and
+                swallowed so they never break the request flow.
         """
         self.max_retries = max_retries
         self.retry_on_rate_limit = retry_on_rate_limit
         self.base_backoff_seconds = base_backoff_seconds
         self.backoff_multiplier = backoff_multiplier
         self.max_retry_delay = max_retry_delay
+        self.on_rate_limit_info = on_rate_limit_info
 
     def calculate_backoff(self, retry_attempt: int) -> float:
         """
@@ -47,6 +130,32 @@ class RateLimitRetryConfig:
         return self.base_backoff_seconds * (self.backoff_multiplier**retry_attempt)
 
 
+def emit_rate_limit_info(
+    response: "Response",
+    config: "RateLimitRetryConfig",
+    method: str,
+    url: str,
+) -> None:
+    """
+    Invoke the ``on_rate_limit_info`` callback if configured.
+
+    Parses rate limit headers off the response and hands them to the user's
+    callback. Any exception raised from the callback is logged and swallowed so
+    a buggy observer never breaks the underlying request.
+    """
+    if config.on_rate_limit_info is None:
+        return
+
+    info = parse_rate_limit_info(response, method=method, url=url)
+    if info is None:
+        return
+
+    try:
+        config.on_rate_limit_info(info)
+    except Exception:
+        logger.exception("on_rate_limit_info callback raised; suppressing")
+
+
 def handle_rate_limit_response(
     response: "Response",
     config: RateLimitRetryConfig,

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client/services/request.py

@@ -12,6 +12,7 @@ import httpx
 from ..version import LAGO_VERSION
 from .rate_limit import (
     RateLimitRetryConfig,
+    emit_rate_limit_info,
     handle_rate_limit_response,
     is_rate_limit_response,
     wait_for_retry,
@@ -92,12 +93,20 @@ def _create_retry_wrapper(
         if rate_limit_retry_config is None:
             rate_limit_retry_config = RateLimitRetryConfig()
 
+        method_name = http_method.__name__.upper()
+
         retry_attempt = 0
         while True:
             response = http_method(url, **kwargs)
 
-            # If not rate limited, return the response
+            # If not rate limited, emit observability info and return the response
             if not is_rate_limit_response(response):
+                emit_rate_limit_info(
+                    response,
+                    rate_limit_retry_config,
+                    method=method_name,
+                    url=url,
+                )
                 return response
 
             # Handle rate limit - may raise LagoRateLimitError or return wait duration

lago_python_client-1.48.0/lago_python_client/version.py

@@ -0,0 +1 @@
+LAGO_VERSION = "1.48.0"

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lago-python-client
-Version: 1.46.0
+Version: 1.48.0
 Summary: Lago Python API Client
 Home-page: https://github.com/getlago/lago-python-client
 Author: Lovro Colic

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/lago_python_client.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ setup.cfg
 ./lago_python_client/exceptions.py
 ./lago_python_client/functools_ext.py
 ./lago_python_client/mixins.py
+./lago_python_client/observability.py
 ./lago_python_client/py.typed
 ./lago_python_client/version.py
 ./lago_python_client/activity_logs/__init__.py
@@ -185,6 +186,7 @@ lago_python_client/client.py
 lago_python_client/exceptions.py
 lago_python_client/functools_ext.py
 lago_python_client/mixins.py
+lago_python_client/observability.py
 lago_python_client/py.typed
 lago_python_client/version.py
 lago_python_client.egg-info/PKG-INFO

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/tests/test_customer_client.py

@@ -134,6 +134,11 @@ def test_valid_current_usage(httpx_mock: HTTPXMock):
     assert response.charges_usage[0].units == "1.0"
     assert len(response.charges_usage[0].filters) == 1
     assert response.charges_usage[0].filters[0].values["country"] == ["france"]
+    charge_usage = response.charges_usage[0]
+    assert charge_usage.presentation_breakdowns.__root__[0].presentation_by["team"] == "engineering"
+    assert charge_usage.presentation_breakdowns.__root__[0].units == "3.0"
+    assert charge_usage.filters[0].presentation_breakdowns.__root__[0].units == "2.0"
+    assert charge_usage.grouped_usage[0].presentation_breakdowns.__root__[0].units == "1.0"
 
 
 def test_valid_projected_usage(httpx_mock: HTTPXMock):
@@ -157,6 +162,11 @@ def test_valid_projected_usage(httpx_mock: HTTPXMock):
     assert response.charges_usage[0].charge.charge_model == "graduated"
     assert response.charges_usage[0].charge.invoice_display_name == "add_on_invoice_display_name"
     assert response.charges_usage[0].billable_metric.lago_id == "99a6094e-199b-4101-896a-54e927ce7bd7"
+    charge_usage = response.charges_usage[0]
+    assert charge_usage.presentation_breakdowns.__root__[0].units == "3.0"
+    assert charge_usage.projected_presentation_breakdowns.__root__[0].units == "6.0"
+    assert charge_usage.filters[0].projected_presentation_breakdowns.__root__[0].units == "4.0"
+    assert charge_usage.grouped_usage[0].projected_presentation_breakdowns.__root__[0].units == "2.0"
 
 
 def test_valid_current_usage_without_taxes(httpx_mock: HTTPXMock):
@@ -204,6 +214,38 @@ def test_valid_current_usage_with_filters(httpx_mock: HTTPXMock):
     assert len(response.charges_usage) == 1
 
 
+def test_valid_current_usage_with_new_filters(httpx_mock: HTTPXMock):
+    client = Client(api_key="886fe239-927d-4072-ab72-6dd345e8dd0d")
+    charge_id = "1a901a90-1a90-1a90-1a90-1a901a901a90"
+
+    httpx_mock.add_response(
+        method="GET",
+        url=(
+            "https://api.getlago.com/api/v1/customers/external_customer_id/current_usage"
+            f"?external_subscription_id=123&charge_id={charge_id}"
+            "&charge_code=storage"
+            "&billable_metric_code=storage"
+            "&group%5Bcloud%5D=aws"
+            "&filter_by_presentation=%5B%22engineering%22%2C+%22operations%22%5D"
+            "&full_usage=true"
+        ),
+        content=mock_response("customer_usage"),
+    )
+    response = client.customers.current_usage(
+        "external_customer_id",
+        "123",
+        charge_id=charge_id,
+        charge_code="storage",
+        billable_metric_code="storage",
+        group={"cloud": "aws"},
+        filter_by_presentation=["engineering", "operations"],
+        full_usage=True,
+    )
+
+    assert response.from_datetime == "2022-07-01T00:00:00Z"
+    assert len(response.charges_usage) == 1
+
+
 def test_invalid_current_usage(httpx_mock: HTTPXMock):
     client = Client(api_key="886fe239-927d-4072-ab72-6dd345e8dd0d")
 
@@ -233,6 +275,8 @@ def test_valid_past_usage(httpx_mock: HTTPXMock):
     assert len(response["usage_periods"][0].charges_usage) == 1
     assert response["usage_periods"][0].charges_usage[0].units == "1.0"
     assert len(response["usage_periods"][0].charges_usage[0].filters) == 1
+    past_charge_usage = response["usage_periods"][0].charges_usage[0]
+    assert past_charge_usage.presentation_breakdowns.__root__[0].units == "3.0"
 
 
 def test_invalid_past_usage(httpx_mock: HTTPXMock):

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/tests/test_fee_client.py

@@ -29,6 +29,8 @@ def test_valid_find_fee_request(httpx_mock: HTTPXMock):
     assert response.lago_id == identifier
     assert response.invoice_display_name == fee_invoice_display_name
     assert response.item.invoice_display_name == charge_invoice_display_name
+    assert response.presentation_breakdowns.__root__[0].presentation_by["team"] == "engineering"
+    assert response.presentation_breakdowns.__root__[0].units == "10.0"
 
 
 def test_fee_response_with_fixed_charge_id():

{lago_python_client-1.46.0 → lago_python_client-1.48.0}/tests/test_plan_client.py

@@ -25,7 +25,14 @@ def plan_object():
         id=None,
         invoice_display_name=None,
         regroup_paid_fees=None,
-        properties=None,
+        properties={
+            "presentation_group_keys": [
+                {
+                    "value": "region",
+                    "options": {"display_in_invoice": True},
+                }
+            ]
+        },
         tax_codes=None,
         billable_metric_id="id",
         charge_model="standard",
@@ -194,6 +201,8 @@ def test_valid_create_plan_request(httpx_mock: HTTPXMock):
     assert response.code == "plan_code"
     assert response.invoice_display_name == "test plan 1"
     assert response.charges.__root__[0].invoice_display_name == "Setup"
+    charge = response.charges.__root__[0]
+    assert charge.properties["presentation_group_keys"][0]["value"] == "region"
     assert response.minimum_commitment.invoice_display_name == "Minimum commitment (C1)"
     assert response.usage_thresholds.__root__[0].threshold_display_name == "Threshold 1"
     assert response.metadata == {"key1": "value1", "key2": None}
@@ -276,6 +285,8 @@ def test_valid_find_plan_request(httpx_mock: HTTPXMock):
     assert response.invoice_display_name == "test plan 1"
     assert response.charges.__root__[0].charge_model == "standard"
     assert response.charges.__root__[0].min_amount_cents == 0
+    charge = response.charges.__root__[0]
+    assert charge.properties["presentation_group_keys"][0]["value"] == "region"
     assert response.minimum_commitment.amount_cents == 1000
 
 
@@ -338,6 +349,8 @@ def test_valid_find_all_plan_request(httpx_mock: HTTPXMock):
     assert response["plans"][0].invoice_display_name == "test plan 1"
     assert response["plans"][0].minimum_commitment.invoice_display_name == "Minimum commitment (C2)"
     assert response["plans"][0].charges.__root__[0].lago_id == "51c1e851-5be6-4343-a0ee-39a81d8b4ee1"
+    plan_charge = response["plans"][0].charges.__root__[0]
+    assert plan_charge.properties["presentation_group_keys"][0]["value"] == "region"
     assert response["plans"][0].charges.__root__[0].filters.__root__[0].properties["amount"] == "0.22"
     assert response["plans"][0].charges.__root__[0].filters.__root__[0].invoice_display_name == "Europe"
     assert response["meta"]["current_page"] == 1
@@ -506,6 +519,9 @@ def test_valid_find_charge_request(httpx_mock: HTTPXMock):
     assert response.code == "charge_code"
     assert response.charge_model == "standard"
     assert response.invoice_display_name == "Setup"
+    presentation_group_key = response.properties["presentation_group_keys"][0]
+    assert presentation_group_key["value"] == "region"
+    assert presentation_group_key["options"]["display_in_invoice"] is True
 
 
 def test_valid_create_charge_request(httpx_mock: HTTPXMock):
@@ -522,12 +538,21 @@ def test_valid_create_charge_request(httpx_mock: HTTPXMock):
         charge_model="standard",
         pay_in_advance=True,
         invoiceable=True,
-        properties={"amount": "0.22"},
+        properties={
+            "amount": "0.22",
+            "presentation_group_keys": [
+                {
+                    "value": "region",
+                    "options": {"display_in_invoice": True},
+                }
+            ],
+        },
     )
     response = client.plan_charges.create(plan_code, charge)
 
     assert response.lago_id == "51c1e851-5be6-4343-a0ee-39a81d8b4ee1"
     assert response.charge_model == "standard"
+    assert charge.dict()["properties"]["presentation_group_keys"][0]["value"] == "region"
 
 
 def test_valid_update_charge_request(httpx_mock: HTTPXMock):