paddle-python-sdk 1.13.1__tar.gz → 1.14.1__tar.gz

{paddle_python_sdk-1.13.1/paddle_python_sdk.egg-info → paddle_python_sdk-1.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paddle-python-sdk
-Version: 1.13.1
+Version: 1.14.1
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-1.13.1 → paddle_python_sdk-1.14.1}/paddle_billing/Client.py

@@ -39,6 +39,7 @@ from paddle_billing.Resources.SimulationRuns.SimulationRunsClient import Simulat
 from paddle_billing.Resources.SimulationRunEvents.SimulationRunEventsClient import SimulationRunEventsClient
 from paddle_billing.Resources.SimulationTypes.SimulationTypesClient import SimulationTypesClient
 from paddle_billing.Resources.Subscriptions.SubscriptionsClient import SubscriptionsClient
+from paddle_billing.Resources.Metrics.MetricsClient import MetricsClient
 from paddle_billing.Resources.Transactions.TransactionsClient import TransactionsClient
 
 
@@ -94,6 +95,7 @@ class Client:
         self.subscriptions = SubscriptionsClient(self)
         self.transactions = TransactionsClient(self)
         self.ip_addresses = IPAddressesClient(self)
+        self.metrics = MetricsClient(self)
 
     @staticmethod
     def null_logger() -> Logger:
@@ -102,7 +104,8 @@ class Client:
         """
 
         null_logger = getLogger("null_logger")
-        null_logger.addHandler(NullHandler())
+        if not null_logger.handlers:
+            null_logger.addHandler(NullHandler())
 
         return null_logger
 
@@ -200,7 +203,7 @@ class Client:
                 "Authorization": f"Bearer {self.__api_key}",
                 "Content-Type": "application/json",
                 "Paddle-Version": str(self.use_api_version),
-                "User-Agent": "PaddleSDK/python 1.13.1",
+                "User-Agent": "PaddleSDK/python 1.14.1",
             }
         )
 

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsActiveSubscribers.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsCountDatapoint import MetricsCountDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+
+
+@dataclass
+class MetricsActiveSubscribers(Entity):
+    timeseries: list[MetricsCountDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsActiveSubscribers:
+        return MetricsActiveSubscribers(
+            timeseries=[MetricsCountDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsAmountDatapoint.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class MetricsAmountDatapoint:
+    timestamp: datetime
+    amount: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsAmountDatapoint:
+        return MetricsAmountDatapoint(
+            timestamp=datetime.fromisoformat(data["timestamp"]),
+            amount=data["amount"],
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsChargebacks.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsCountDatapoint import MetricsCountDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+
+
+@dataclass
+class MetricsChargebacks(Entity):
+    timeseries: list[MetricsCountDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsChargebacks:
+        return MetricsChargebacks(
+            timeseries=[MetricsCountDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsCheckoutConversion.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsCheckoutConversionDatapoint import MetricsCheckoutConversionDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+
+
+@dataclass
+class MetricsCheckoutConversion(Entity):
+    timeseries: list[MetricsCheckoutConversionDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsCheckoutConversion:
+        return MetricsCheckoutConversion(
+            timeseries=[MetricsCheckoutConversionDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsCheckoutConversionDatapoint.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class MetricsCheckoutConversionDatapoint:
+    timestamp: datetime
+    count: int
+    completed_count: int
+    rate: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsCheckoutConversionDatapoint:
+        return MetricsCheckoutConversionDatapoint(
+            timestamp=datetime.fromisoformat(data["timestamp"]),
+            count=data["count"],
+            completed_count=data["completed_count"],
+            rate=data["rate"],
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsCountDatapoint.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class MetricsCountDatapoint:
+    timestamp: datetime
+    count: int
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsCountDatapoint:
+        return MetricsCountDatapoint(
+            timestamp=datetime.fromisoformat(data["timestamp"]),
+            count=data["count"],
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsInterval.py

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class MetricsInterval(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Day: "MetricsInterval" = "day"

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsMonthlyRecurringRevenue.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsAmountDatapoint import MetricsAmountDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class MetricsMonthlyRecurringRevenue(Entity):
+    currency_code: CurrencyCode
+    timeseries: list[MetricsAmountDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsMonthlyRecurringRevenue:
+        return MetricsMonthlyRecurringRevenue(
+            currency_code=CurrencyCode(data["currency_code"]),
+            timeseries=[MetricsAmountDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsMonthlyRecurringRevenueChange.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsAmountDatapoint import MetricsAmountDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class MetricsMonthlyRecurringRevenueChange(Entity):
+    currency_code: CurrencyCode
+    timeseries: list[MetricsAmountDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsMonthlyRecurringRevenueChange:
+        return MetricsMonthlyRecurringRevenueChange(
+            currency_code=CurrencyCode(data["currency_code"]),
+            timeseries=[MetricsAmountDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsRefunds.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsAmountDatapoint import MetricsAmountDatapoint
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class MetricsRefunds(Entity):
+    currency_code: CurrencyCode
+    timeseries: list[MetricsAmountDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsRefunds:
+        return MetricsRefunds(
+            currency_code=CurrencyCode(data["currency_code"]),
+            timeseries=[MetricsAmountDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsRevenue.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+from paddle_billing.Entities.Metrics.MetricsRevenueDatapoint import MetricsRevenueDatapoint
+from paddle_billing.Entities.Shared import CurrencyCode
+
+
+@dataclass
+class MetricsRevenue(Entity):
+    currency_code: CurrencyCode
+    timeseries: list[MetricsRevenueDatapoint]
+    starts_at: datetime
+    ends_at: datetime
+    interval: MetricsInterval
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsRevenue:
+        return MetricsRevenue(
+            currency_code=CurrencyCode(data["currency_code"]),
+            timeseries=[MetricsRevenueDatapoint.from_dict(dp) for dp in data.get("timeseries", [])],
+            starts_at=datetime.fromisoformat(data["starts_at"]),
+            ends_at=datetime.fromisoformat(data["ends_at"]),
+            interval=MetricsInterval(data["interval"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/MetricsRevenueDatapoint.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class MetricsRevenueDatapoint:
+    timestamp: datetime
+    amount: str
+    count: int
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> MetricsRevenueDatapoint:
+        return MetricsRevenueDatapoint(
+            timestamp=datetime.fromisoformat(data["timestamp"]),
+            amount=data["amount"],
+            count=data["count"],
+        )

paddle_python_sdk-1.14.1/paddle_billing/Entities/Metrics/__init__.py

@@ -0,0 +1,12 @@
+from paddle_billing.Entities.Metrics.MetricsInterval import MetricsInterval
+from paddle_billing.Entities.Metrics.MetricsAmountDatapoint import MetricsAmountDatapoint
+from paddle_billing.Entities.Metrics.MetricsCountDatapoint import MetricsCountDatapoint
+from paddle_billing.Entities.Metrics.MetricsRevenueDatapoint import MetricsRevenueDatapoint
+from paddle_billing.Entities.Metrics.MetricsCheckoutConversionDatapoint import MetricsCheckoutConversionDatapoint
+from paddle_billing.Entities.Metrics.MetricsMonthlyRecurringRevenue import MetricsMonthlyRecurringRevenue
+from paddle_billing.Entities.Metrics.MetricsMonthlyRecurringRevenueChange import MetricsMonthlyRecurringRevenueChange
+from paddle_billing.Entities.Metrics.MetricsActiveSubscribers import MetricsActiveSubscribers
+from paddle_billing.Entities.Metrics.MetricsRevenue import MetricsRevenue
+from paddle_billing.Entities.Metrics.MetricsRefunds import MetricsRefunds
+from paddle_billing.Entities.Metrics.MetricsChargebacks import MetricsChargebacks
+from paddle_billing.Entities.Metrics.MetricsCheckoutConversion import MetricsCheckoutConversion

paddle_python_sdk-1.14.1/paddle_billing/Resources/Metrics/MetricsClient.py

@@ -0,0 +1,64 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Metrics.MetricsActiveSubscribers import MetricsActiveSubscribers
+from paddle_billing.Entities.Metrics.MetricsChargebacks import MetricsChargebacks
+from paddle_billing.Entities.Metrics.MetricsCheckoutConversion import MetricsCheckoutConversion
+from paddle_billing.Entities.Metrics.MetricsMonthlyRecurringRevenue import MetricsMonthlyRecurringRevenue
+from paddle_billing.Entities.Metrics.MetricsMonthlyRecurringRevenueChange import MetricsMonthlyRecurringRevenueChange
+from paddle_billing.Entities.Metrics.MetricsRefunds import MetricsRefunds
+from paddle_billing.Entities.Metrics.MetricsRevenue import MetricsRevenue
+
+from paddle_billing.Resources.Metrics.Operations import GetMetrics
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class MetricsClient:
+    def __init__(self, client: "Client"):
+        self.client = client
+        self.response = None
+
+    def get_monthly_recurring_revenue(self, operation: GetMetrics) -> MetricsMonthlyRecurringRevenue:
+        self.response = self.client.get_raw("/metrics/monthly-recurring-revenue", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsMonthlyRecurringRevenue.from_dict(parser.get_dict())
+
+    def get_monthly_recurring_revenue_change(self, operation: GetMetrics) -> MetricsMonthlyRecurringRevenueChange:
+        self.response = self.client.get_raw("/metrics/monthly-recurring-revenue-change", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsMonthlyRecurringRevenueChange.from_dict(parser.get_dict())
+
+    def get_active_subscribers(self, operation: GetMetrics) -> MetricsActiveSubscribers:
+        self.response = self.client.get_raw("/metrics/active-subscribers", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsActiveSubscribers.from_dict(parser.get_dict())
+
+    def get_revenue(self, operation: GetMetrics) -> MetricsRevenue:
+        self.response = self.client.get_raw("/metrics/revenue", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsRevenue.from_dict(parser.get_dict())
+
+    def get_refunds(self, operation: GetMetrics) -> MetricsRefunds:
+        self.response = self.client.get_raw("/metrics/refunds", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsRefunds.from_dict(parser.get_dict())
+
+    def get_chargebacks(self, operation: GetMetrics) -> MetricsChargebacks:
+        self.response = self.client.get_raw("/metrics/chargebacks", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsChargebacks.from_dict(parser.get_dict())
+
+    def get_checkout_conversion(self, operation: GetMetrics) -> MetricsCheckoutConversion:
+        self.response = self.client.get_raw("/metrics/checkout-conversion", operation.get_parameters())
+        parser = ResponseParser(self.response)
+
+        return MetricsCheckoutConversion.from_dict(parser.get_dict())

paddle_python_sdk-1.14.1/paddle_billing/Resources/Metrics/Operations/GetMetrics.py

@@ -0,0 +1,33 @@
+from datetime import date
+
+from paddle_billing.HasParameters import HasParameters
+
+
+class GetMetrics(HasParameters):
+    def __init__(
+        self,
+        date_from: str,
+        date_to: str,
+    ):
+        self.date_from = date_from
+        self.date_to = date_to
+
+        for field_name, field_value in [
+            ("date_from", self.date_from),
+            ("date_to", self.date_to),
+        ]:
+            try:
+                date.fromisoformat(field_value)
+            except (ValueError, TypeError):
+                raise ValueError(f"'{field_name}' must be a date string in YYYY-MM-DD format, got '{field_value}'")
+
+            if "T" in field_value:
+                raise ValueError(
+                    f"'{field_name}' must be a date string in YYYY-MM-DD format without time, got '{field_value}'"
+                )
+
+    def get_parameters(self) -> dict[str, str]:
+        return {
+            "from": self.date_from,
+            "to": self.date_to,
+        }

paddle_python_sdk-1.14.1/paddle_billing/Resources/Metrics/Operations/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Resources.Metrics.Operations.GetMetrics import GetMetrics

{paddle_python_sdk-1.13.1 → paddle_python_sdk-1.14.1/paddle_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paddle-python-sdk
-Version: 1.13.1
+Version: 1.14.1
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-1.13.1 → paddle_python_sdk-1.14.1}/paddle_python_sdk.egg-info/SOURCES.txt

@@ -106,6 +106,19 @@ paddle_billing/Entities/Discounts/DiscountType.py
 paddle_billing/Entities/Discounts/__init__.py
 paddle_billing/Entities/Events/EventTypeName.py
 paddle_billing/Entities/Events/__init__.py
+paddle_billing/Entities/Metrics/MetricsActiveSubscribers.py
+paddle_billing/Entities/Metrics/MetricsAmountDatapoint.py
+paddle_billing/Entities/Metrics/MetricsChargebacks.py
+paddle_billing/Entities/Metrics/MetricsCheckoutConversion.py
+paddle_billing/Entities/Metrics/MetricsCheckoutConversionDatapoint.py
+paddle_billing/Entities/Metrics/MetricsCountDatapoint.py
+paddle_billing/Entities/Metrics/MetricsInterval.py
+paddle_billing/Entities/Metrics/MetricsMonthlyRecurringRevenue.py
+paddle_billing/Entities/Metrics/MetricsMonthlyRecurringRevenueChange.py
+paddle_billing/Entities/Metrics/MetricsRefunds.py
+paddle_billing/Entities/Metrics/MetricsRevenue.py
+paddle_billing/Entities/Metrics/MetricsRevenueDatapoint.py
+paddle_billing/Entities/Metrics/__init__.py
 paddle_billing/Entities/NotificationSettings/NotificationSettingTrafficSource.py
 paddle_billing/Entities/NotificationSettings/NotificationSettingType.py
 paddle_billing/Entities/NotificationSettings/__init__.py
@@ -559,6 +572,10 @@ paddle_billing/Resources/Events/Operations/ListEvents.py
 paddle_billing/Resources/Events/Operations/__init__.py
 paddle_billing/Resources/IPAddresses/IPAddressesClient.py
 paddle_billing/Resources/IPAddresses/__init__.py
+paddle_billing/Resources/Metrics/MetricsClient.py
+paddle_billing/Resources/Metrics/__init__.py
+paddle_billing/Resources/Metrics/Operations/GetMetrics.py
+paddle_billing/Resources/Metrics/Operations/__init__.py
 paddle_billing/Resources/NotificationLogs/NotificationLogsClient.py
 paddle_billing/Resources/NotificationLogs/__init__.py
 paddle_billing/Resources/NotificationLogs/Operations/ListNotificationLogs.py
@@ -770,6 +787,8 @@ tests/Functional/Resources/Events/__init__.py
 tests/Functional/Resources/Events/test_EventsClient.py
 tests/Functional/Resources/IPAddresses/__init__.py
 tests/Functional/Resources/IPAddresses/test_IPAddressesClient.py
+tests/Functional/Resources/Metrics/__init__.py
+tests/Functional/Resources/Metrics/test_MetricsClient.py
 tests/Functional/Resources/NotificationLogs/__init__.py
 tests/Functional/Resources/NotificationLogs/test_NotificationLogsClient.py
 tests/Functional/Resources/NotificationSettings/__init__.py

{paddle_python_sdk-1.13.1 → paddle_python_sdk-1.14.1}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 
 setup(
-    version="1.13.1",
+    version="1.14.1",
     author="Paddle and contributors",
     author_email="team-dx@paddle.com",
     description="Paddle's Python SDK for Paddle Billing",

paddle_python_sdk-1.14.1/tests/Functional/Resources/Metrics/test_MetricsClient.py

@@ -0,0 +1,112 @@
+from json import dumps, loads
+from paddle_billing.Json import PayloadEncoder
+from pytest import mark
+from urllib.parse import unquote
+
+from paddle_billing.Entities.Metrics import (
+    MetricsActiveSubscribers,
+    MetricsChargebacks,
+    MetricsCheckoutConversion,
+    MetricsMonthlyRecurringRevenue,
+    MetricsMonthlyRecurringRevenueChange,
+    MetricsRefunds,
+    MetricsRevenue,
+)
+
+from paddle_billing.Resources.Metrics.Operations import GetMetrics
+
+from tests.Utils.ReadsFixture import ReadsFixtures
+
+
+class TestMetricsClient:
+    @mark.parametrize(
+        "method, operation, expected_response_body, expected_url, expected_entity_type",
+        [
+            (
+                "get_monthly_recurring_revenue",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/monthly_recurring_revenue"),
+                "/metrics/monthly-recurring-revenue?from=2025-09-01&to=2025-09-05",
+                MetricsMonthlyRecurringRevenue,
+            ),
+            (
+                "get_monthly_recurring_revenue_change",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/monthly_recurring_revenue_change"),
+                "/metrics/monthly-recurring-revenue-change?from=2025-09-01&to=2025-09-05",
+                MetricsMonthlyRecurringRevenueChange,
+            ),
+            (
+                "get_active_subscribers",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/active_subscribers"),
+                "/metrics/active-subscribers?from=2025-09-01&to=2025-09-05",
+                MetricsActiveSubscribers,
+            ),
+            (
+                "get_revenue",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/revenue"),
+                "/metrics/revenue?from=2025-09-01&to=2025-09-05",
+                MetricsRevenue,
+            ),
+            (
+                "get_refunds",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/refunds"),
+                "/metrics/refunds?from=2025-09-01&to=2025-09-05",
+                MetricsRefunds,
+            ),
+            (
+                "get_chargebacks",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/chargebacks"),
+                "/metrics/chargebacks?from=2025-09-01&to=2025-09-05",
+                MetricsChargebacks,
+            ),
+            (
+                "get_checkout_conversion",
+                GetMetrics(date_from="2025-09-01", date_to="2025-09-05"),
+                ReadsFixtures.read_raw_json_fixture("response/checkout_conversion"),
+                "/metrics/checkout-conversion?from=2025-09-01&to=2025-09-05",
+                MetricsCheckoutConversion,
+            ),
+        ],
+        ids=[
+            "Get monthly recurring revenue",
+            "Get monthly recurring revenue change",
+            "Get active subscribers",
+            "Get revenue",
+            "Get refunds",
+            "Get chargebacks",
+            "Get checkout conversion",
+        ],
+    )
+    def test_metrics_returns_expected_response(
+        self,
+        test_client,
+        mock_requests,
+        method,
+        operation,
+        expected_response_body,
+        expected_url,
+        expected_entity_type,
+    ):
+        expected_url = f"{test_client.base_url}{expected_url}"
+        mock_requests.get(expected_url, status_code=200, text=expected_response_body)
+
+        response = getattr(test_client.client.metrics, method)(operation)
+        response_json = test_client.client.metrics.response.json()
+        last_request = mock_requests.last_request
+
+        assert isinstance(response, expected_entity_type)
+        assert last_request is not None
+        assert last_request.method == "GET"
+        assert test_client.client.status_code == 200
+        assert unquote(last_request.url) == expected_url, "The URL does not match the expected URL"
+        assert (
+            loads(dumps(response, cls=PayloadEncoder)) == loads(str(expected_response_body))["data"]
+        ), "The metrics response object doesn't match the expected fixture JSON"
+        assert response_json == loads(
+            str(expected_response_body)
+        ), "The response JSON doesn't match the expected fixture JSON"