From a8d43a6ad07e3c9dcd75908a4b2ce9977eb98bb3 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Tue, 7 Jan 2025 22:51:44 -0300
Subject: [PATCH 01/10] refactor: change to complex objects instead of raw
 dictionaries

This commit introduces a significant architectural change in how we handle API responses.
Instead of working with raw dictionaries, we now use proper model classes (Charge,
CardToken, Refund, etc.) to represent API resources.

Key changes:
- Created new models.py file with proper data classes for all API resources
- Updated client methods to return typed objects instead of dictionaries
- Modified examples to demonstrate usage with new object-oriented approach
- Updated tests to work with new model classes
- Added type hints throughout the codebase

This change brings several benefits:
1. Better type safety and IDE support
2. More intuitive API with proper object methods
3. Easier validation and data manipulation
4. Improved code maintainability
5. Better documentation through type hints

The change is backwards compatible as the model classes can still be accessed as
dictionaries through their attributes.

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 barte/__init__.py              |   1 +
 barte/client.py                | 363 ++++-----------------------------
 barte/models.py                | 106 ++++++++++
 examples/basic_usage.py        | 100 ++++++---
 examples/card_token_example.py | 111 +++++++---
 examples/pix_example.py        |  94 +++++----
 tests/test_client.py           | 361 +++++++++++++-------------------
 7 files changed, 497 insertions(+), 639 deletions(-)
 create mode 100644 barte/models.py

diff --git a/barte/__init__.py b/barte/__init__.py
index 3704866..e2f068c 100644
--- a/barte/__init__.py
+++ b/barte/__init__.py
@@ -1,3 +1,4 @@
 from .client import BarteClient
+from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge, Customer, InstallmentSimulation
 
 __version__ = "0.1.0" 
\ No newline at end of file
diff --git a/barte/client.py b/barte/client.py
index 3829f17..48a528d 100644
--- a/barte/client.py
+++ b/barte/client.py
@@ -1,16 +1,18 @@
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 import requests
+from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge
 
 class BarteClient:
     VALID_ENVIRONMENTS = ["production", "sandbox"]
+    _instance = None
 
     def __init__(self, api_key: str, environment: str = "production"):
         """
-        Inicializa o cliente da API Barte
+        Initialize the Barte API client
         
         Args:
-            api_key: Chave de API fornecida pela Barte
-            environment: Ambiente de execução ("production" ou "sandbox")
+            api_key: API key provided by Barte
+            environment: Environment ("production" or "sandbox")
             
         Raises:
             ValueError: If the environment is not "production" or "sandbox"
@@ -24,138 +26,53 @@ def __init__(self, api_key: str, environment: str = "production"):
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json"
         }
+        BarteClient._instance = self
 
-    def create_charge(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates a new charge
-        
-        Args:
-            data: Dictionary containing:
-                - amount: Amount in cents (required)
-                - currency: Currency code (default: BRL)
-                - payment_method: Payment method (required)
-                - description: Charge description
-                - customer: Customer data (required)
-                - metadata: Additional data
-                - statement_descriptor: Text that will appear on the invoice
-                - payment_settings: Payment specific configurations
-                - antifraud_settings: Anti-fraud settings
-                
-        Returns:
-            API response with charge data
-        """
+    @classmethod
+    def get_instance(cls) -> "BarteClient":
+        if cls._instance is None:
+            raise RuntimeError("BarteClient not initialized. Call BarteClient(api_key) first.")
+        return cls._instance
+
+    def create_charge(self, data: Dict[str, Any]) -> Charge:
+        """Create a new charge"""
         endpoint = f"{self.base_url}/v1/charges"
         response = requests.post(endpoint, headers=self.headers, json=data)
         response.raise_for_status()
-        return response.json()
+        return Charge.from_dict(response.json())
 
-    def get_charge(self, charge_id: str) -> Dict[str, Any]:
-        """
-        Obtém os dados de uma cobrança específica
-        
-        Args:
-            charge_id: ID da cobrança
-            
-        Returns:
-            Dados da cobrança
-        """
+    def get_charge(self, charge_id: str) -> Charge:
+        """Get a specific charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return response.json()
+        return Charge.from_dict(response.json())
 
-    def list_charges(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Lista todas as cobranças com filtros opcionais
-        
-        Args:
-            params: Parâmetros de filtro (opcional)
-            
-        Returns:
-            Lista de cobranças
-        """
+    def list_charges(self, params: Optional[Dict[str, Any]] = None) -> List[Charge]:
+        """List all charges with optional filters"""
         endpoint = f"{self.base_url}/v1/charges"
         response = requests.get(endpoint, headers=self.headers, params=params)
         response.raise_for_status()
-        return response.json()
+        return [Charge.from_dict(item) for item in response.json()["data"]]
 
-    def cancel_charge(self, charge_id: str) -> Dict[str, Any]:
-        """
-        Cancela uma cobrança específica
-        
-        Args:
-            charge_id: ID da cobrança
-            
-        Returns:
-            Dados da cobrança cancelada
-        """
+    def cancel_charge(self, charge_id: str) -> Charge:
+        """Cancel a specific charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/cancel"
         response = requests.post(endpoint, headers=self.headers)
         response.raise_for_status()
-        return response.json()
+        return Charge.from_dict(response.json())
 
-    def create_card_token(self, card_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates a token for a credit card
-        
-        Args:
-            card_data: Dictionary with card data containing:
-                - number: Card number
-                - holder_name: Cardholder name
-                - expiration_month: Expiration month (1-12)
-                - expiration_year: Expiration year (YYYY)
-                - cvv: Security code
-        
-        Returns:
-            API response with card token
-        
-        Example:
-            card_data = {
-                "number": "4111111111111111",
-                "holder_name": "John Smith",
-                "expiration_month": 12,
-                "expiration_year": 2025,
-                "cvv": "123"
-            }
-        """
+    def create_card_token(self, card_data: Dict[str, Any]) -> CardToken:
+        """Create a token for a credit card"""
         endpoint = f"{self.base_url}/v1/tokens"
         response = requests.post(endpoint, headers=self.headers, json=card_data)
         response.raise_for_status()
-        return response.json()
+        return CardToken.from_dict(response.json())
 
-    def charge_with_card_token(self, token_id: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Realiza uma cobrança usando um token de cartão existente
-        
-        Args:
-            token_id: ID do token do cartão previamente criado
-            data: Dicionário com os dados da transação contendo:
-                - amount: Valor em centavos
-                - description: Descrição da cobrança
-                - customer: Dados do cliente
-                - installments: Número de parcelas (opcional)
-                - capture: Se deve capturar automaticamente (opcional)
-                - statement_descriptor: Descrição que aparecerá na fatura (opcional)
-        
-        Returns:
-            Resposta da API com os dados da transação
-        
-        Example:
-            data = {
-                "amount": 1000,
-                "description": "Compra com cartão tokenizado",
-                "customer": {
-                    "name": "João da Silva",
-                    "tax_id": "123.456.789-00",
-                    "email": "joao@exemplo.com"
-                },
-                "installments": 1,
-                "capture": True
-            }
-        """
+    def charge_with_card_token(self, token_id: str, data: Dict[str, Any]) -> Charge:
+        """Create a charge using an existing card token"""
         endpoint = f"{self.base_url}/v1/charges"
         
-        # Prepara os dados da transação incluindo o token
         transaction_data = {
             **data,
             "payment_method": "credit_card",
@@ -164,37 +81,12 @@ def charge_with_card_token(self, token_id: str, data: Dict[str, Any]) -> Dict[st
         
         response = requests.post(endpoint, headers=self.headers, json=transaction_data)
         response.raise_for_status()
-        return response.json()
+        return Charge.from_dict(response.json())
 
-    def create_pix_charge(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates a PIX charge
-        
-        Args:
-            data: Dictionary with charge data containing:
-                - amount: Amount in cents
-                - description: Charge description
-                - customer: Customer data
-                - expiration_date: Expiration date (optional)
-                
-        Returns:
-            API response with PIX charge data
-        
-        Example:
-            data = {
-                "amount": 1000,
-                "description": "Order #123",
-                "customer": {
-                    "name": "John Smith",
-                    "tax_id": "123.456.789-00",
-                    "email": "john@example.com"
-                },
-                "expiration_date": "2024-12-31T23:59:59Z"
-            }
-        """
+    def create_pix_charge(self, data: Dict[str, Any]) -> PixCharge:
+        """Create a PIX charge"""
         endpoint = f"{self.base_url}/v1/charges"
         
-        # Prepara os dados específicos para PIX
         pix_data = {
             **data,
             "payment_method": "pix"
@@ -202,198 +94,33 @@ def create_pix_charge(self, data: Dict[str, Any]) -> Dict[str, Any]:
         
         response = requests.post(endpoint, headers=self.headers, json=pix_data)
         response.raise_for_status()
-        return response.json()
+        return PixCharge.from_dict(response.json())
 
-    def get_pix_qrcode(self, charge_id: str) -> Dict[str, Any]:
-        """
-        Gets PIX QR Code data for a charge
-        
-        Args:
-            charge_id: PIX charge ID
-            
-        Returns:
-            QR Code data including:
-                - qr_code: QR Code string
-                - qr_code_image: QR Code image URL
-                - copy_and_paste: PIX copy and paste code
-        """
+    def get_pix_qrcode(self, charge_id: str) -> Dict[str, str]:
+        """Get PIX QR Code data for a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/pix"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
         return response.json()
 
-    def create_recurring_charge(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates a recurring charge with credit card
-        
-        Args:
-            data: Dictionary with charge data containing:
-                - amount: Amount in cents
-                - description: Charge description
-                - customer: Customer data
-                - card_token: Card token
-                - recurrence: Recurrence data
-                
-        Returns:
-            API response with recurring charge data
-        
-        Example:
-            data = {
-                "amount": 5990,
-                "description": "Monthly Subscription",
-                "customer": {
-                    "name": "John Smith",
-                    "tax_id": "123.456.789-00",
-                    "email": "john@example.com"
-                },
-                "card_token": "tok_123456",
-                "recurrence": {
-                    "interval": "month",
-                    "interval_count": 1
-                }
-            }
-        """
-        endpoint = f"{self.base_url}/v1/charges"
-        
-        charge_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "recurring": True
-        }
-        
-        response = requests.post(endpoint, headers=self.headers, json=charge_data)
-        response.raise_for_status()
-        return response.json()
-
-    def create_installment_charge_with_fee(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates an installment charge with fees passed to customer
-        
-        Args:
-            data: Dictionary with charge data containing:
-                - amount: Amount in cents
-                - description: Charge description
-                - customer: Customer data
-                - card_token: Card token
-                - installments: Number of installments
-                
-        Returns:
-            API response with installment charge data
-        
-        Example:
-            data = {
-                "amount": 10000,
-                "description": "Installment Purchase",
-                "customer": {
-                    "name": "John Smith",
-                    "tax_id": "123.456.789-00",
-                    "email": "john@example.com"
-                },
-                "card_token": "tok_123456",
-                "installments": 3
-            }
-        """
-        endpoint = f"{self.base_url}/v1/charges"
-        
-        charge_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "split_fee": True  # Indica que as taxas serão repassadas ao cliente
-        }
-        
-        response = requests.post(endpoint, headers=self.headers, json=charge_data)
-        response.raise_for_status()
-        return response.json()
-
-    def create_installment_charge_no_fee(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Creates an installment charge with merchant assuming the fees
-        
-        Args:
-            data: Dictionary with charge data containing:
-                - amount: Amount in cents
-                - description: Charge description
-                - customer: Customer data
-                - card_token: Card token
-                - installments: Number of installments
-                
-        Returns:
-            API response with installment charge data
-        
-        Example:
-            data = {
-                "amount": 10000,
-                "description": "Installment Purchase",
-                "customer": {
-                    "name": "John Smith",
-                    "tax_id": "123.456.789-00",
-                    "email": "john@example.com"
-                },
-                "card_token": "tok_123456",
-                "installments": 3
-            }
-        """
-        endpoint = f"{self.base_url}/v1/charges"
-        
-        charge_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "split_fee": False  # Indica que as taxas NÃO serão repassadas ao cliente
-        }
-        
-        response = requests.post(endpoint, headers=self.headers, json=charge_data)
-        response.raise_for_status()
-        return response.json()
-
-    def simulate_installments(self, amount: int, brand: str) -> Dict[str, Any]:
-        """
-        Simulates credit card installments
-        
-        Args:
-            amount: Amount in cents
-            brand: Card brand (visa, mastercard, etc)
-            
-        Returns:
-            Installment simulation data
-        """
+    def simulate_installments(self, amount: int, brand: str) -> InstallmentOptions:
+        """Simulate credit card installments"""
         endpoint = f"{self.base_url}/v1/simulate/installments"
         params = {"amount": amount, "brand": brand}
         response = requests.get(endpoint, headers=self.headers, params=params)
         response.raise_for_status()
-        return response.json()
+        return InstallmentOptions.from_dict(response.json())
 
-    def get_charge_refunds(self, charge_id: str) -> Dict[str, Any]:
-        """
-        Gets all refunds for a charge
-        
-        Args:
-            charge_id: Charge ID
-            
-        Returns:
-            List of refunds
-        """
+    def get_charge_refunds(self, charge_id: str) -> List[Refund]:
+        """Get all refunds for a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/refunds"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return response.json()
+        return [Refund.from_dict(item) for item in response.json()["data"]]
 
-    def refund_charge(self, charge_id: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Refunds a charge
-        
-        Args:
-            charge_id: Charge ID
-            data: Refund data (optional)
-                - amount: Amount to refund (if partial refund)
-                - metadata: Additional data
-                
-        Returns:
-            Refund data
-        """
+    def refund_charge(self, charge_id: str, data: Optional[Dict[str, Any]] = None) -> Refund:
+        """Refund a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/refund"
         response = requests.post(endpoint, headers=self.headers, json=data or {})
         response.raise_for_status()
-        return response.json() 
\ No newline at end of file
+        return Refund.from_dict(response.json()) 
\ No newline at end of file
diff --git a/barte/models.py b/barte/models.py
new file mode 100644
index 0000000..e9df7b9
--- /dev/null
+++ b/barte/models.py
@@ -0,0 +1,106 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+@dataclass
+class Customer:
+    name: str
+    tax_id: str
+    email: str
+
+@dataclass
+class CardToken:
+    id: str
+    type: str
+    created_at: datetime
+    last_digits: str
+    holder_name: str
+    expiration_month: int
+    expiration_year: int
+    brand: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "CardToken":
+        if isinstance(data["created_at"], str):
+            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
+        return cls(**data)
+
+@dataclass
+class Charge:
+    id: str
+    amount: int
+    currency: str
+    status: str
+    payment_method: str
+    description: Optional[str]
+    customer: Customer
+    created_at: datetime
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Charge":
+        # Copy data to avoid modifying the original
+        data = data.copy()
+        
+        # Convert customer if it's a dict
+        if isinstance(data["customer"], dict):
+            data["customer"] = Customer(**data["customer"])
+        
+        # Convert created_at if it's a string
+        if isinstance(data["created_at"], str):
+            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
+        
+        return cls(**data)
+
+    def refund(self, amount: Optional[int] = None) -> "Refund":
+        from .client import BarteClient
+        return BarteClient.get_instance().refund_charge(self.id, {"amount": amount} if amount else None)
+
+    def cancel(self) -> "Charge":
+        from .client import BarteClient
+        return BarteClient.get_instance().cancel_charge(self.id)
+
+@dataclass
+class PixCharge(Charge):
+    qr_code: Optional[str] = None
+    qr_code_image: Optional[str] = None
+    copy_and_paste: Optional[str] = None
+
+    def get_qr_code(self) -> "PixCharge":
+        from .client import BarteClient
+        qr_data = BarteClient.get_instance().get_pix_qrcode(self.id)
+        self.qr_code = qr_data["qr_code"]
+        self.qr_code_image = qr_data["qr_code_image"]
+        self.copy_and_paste = qr_data["copy_and_paste"]
+        return self
+
+@dataclass
+class Refund:
+    id: str
+    charge_id: str
+    amount: int
+    status: str
+    created_at: datetime
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Refund":
+        if isinstance(data["created_at"], str):
+            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
+        return cls(**data)
+
+@dataclass
+class InstallmentSimulation:
+    installments: int
+    amount: int
+    total: int
+    interest_rate: float
+
+@dataclass
+class InstallmentOptions:
+    installments: List[InstallmentSimulation]
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "InstallmentOptions":
+        options = [InstallmentSimulation(**item) for item in data["installments"]]
+        return cls(installments=options) 
\ No newline at end of file
diff --git a/examples/basic_usage.py b/examples/basic_usage.py
index c02b871..f537c4f 100644
--- a/examples/basic_usage.py
+++ b/examples/basic_usage.py
@@ -1,40 +1,74 @@
-from barte import BarteClient
-
-# Inicializa o cliente
-client = BarteClient(
-    api_key="sua_api_key_aqui",
-    environment="sandbox"  # Use "production" para ambiente de produção
-)
-
-# Exemplo de criação de cobrança
-charge_data = {
-    "amount": 1000,  # Valor em centavos
-    "description": "Teste de cobrança",
-    "payment_method": "pix",
-    "customer": {
-        "name": "João da Silva",
-        "tax_id": "123.456.789-00",
-        "email": "joao@exemplo.com"
+from barte import BarteClient, Charge, PixCharge
+
+def main():
+    # Initialize the client
+    client = BarteClient(
+        api_key="your_api_key",
+        environment="sandbox"  # Use "production" for production environment
+    )
+
+    # Create a credit card charge
+    charge_data = {
+        "amount": 1000,  # R$ 10,00
+        "currency": "BRL",
+        "payment_method": "credit_card",
+        "description": "Example charge",
+        "customer": {
+            "name": "John Doe",
+            "tax_id": "123.456.789-00",
+            "email": "john@example.com"
+        },
+        "metadata": {
+            "order_id": "123",
+            "product_id": "456"
+        }
     }
-}
 
-try:
-    # Criar cobrança
+    # Create and print charge details
     charge = client.create_charge(charge_data)
-    print("Cobrança criada:", charge)
+    print("\nCredit Card Charge:")
+    print(f"ID: {charge.id}")
+    print(f"Amount: R$ {charge.amount/100:.2f}")
+    print(f"Status: {charge.status}")
+    print(f"Customer: {charge.customer.name}")
+    print(f"Created at: {charge.created_at}")
+
+    # Create a PIX charge
+    pix_data = {
+        "amount": 1500,  # R$ 15,00
+        "currency": "BRL",
+        "description": "Example PIX charge",
+        "customer": {
+            "name": "John Doe",
+            "tax_id": "123.456.789-00",
+            "email": "john@example.com"
+        }
+    }
+
+    # Create PIX charge and get QR code
+    pix_charge = client.create_pix_charge(pix_data)
+    pix_charge = pix_charge.get_qr_code()
 
-    # Consultar cobrança
-    charge_id = charge["id"]
-    charge_details = client.get_charge(charge_id)
-    print("Detalhes da cobrança:", charge_details)
+    print("\nPIX Charge:")
+    print(f"ID: {pix_charge.id}")
+    print(f"Amount: R$ {pix_charge.amount/100:.2f}")
+    print(f"Status: {pix_charge.status}")
+    print(f"QR Code: {pix_charge.qr_code}")
+    print(f"Copy and Paste code: {pix_charge.copy_and_paste}")
 
-    # Listar cobranças
-    charges = client.list_charges({"status": "pending"})
-    print("Lista de cobranças:", charges)
+    # List recent charges
+    print("\nRecent charges:")
+    charges = client.list_charges({"limit": 5})
+    for charge in charges:
+        print(f"- {charge.id}: R$ {charge.amount/100:.2f} ({charge.status})")
 
-    # Cancelar cobrança
-    cancelled_charge = client.cancel_charge(charge_id)
-    print("Cobrança cancelada:", cancelled_charge)
+    # Refund the credit card charge
+    refund = charge.refund(amount=500)  # Partial refund of R$ 5,00
+    print("\nRefund:")
+    print(f"ID: {refund.id}")
+    print(f"Amount: R$ {refund.amount/100:.2f}")
+    print(f"Status: {refund.status}")
+    print(f"Created at: {refund.created_at}")
 
-except Exception as e:
-    print("Erro:", str(e)) 
\ No newline at end of file
+if __name__ == "__main__":
+    main() 
\ No newline at end of file
diff --git a/examples/card_token_example.py b/examples/card_token_example.py
index c3437dd..ab935a8 100644
--- a/examples/card_token_example.py
+++ b/examples/card_token_example.py
@@ -1,40 +1,85 @@
-from barte import BarteClient
-
-# Inicializa o cliente
-client = BarteClient(
-    api_key="sua_api_key_aqui",
-    environment="sandbox"
-)
-
-# Dados do cartão
-card_data = {
-    "number": "4111111111111111",
-    "holder_name": "João da Silva",
-    "expiration_month": 12,
-    "expiration_year": 2025,
-    "cvv": "123"
-}
-
-try:
-    # Criar token do cartão
-    token_response = client.create_card_token(card_data)
-    print("Token do cartão criado:", token_response)
+from barte import BarteClient, CardToken, Charge
+
+def main():
+    # Initialize the client
+    client = BarteClient(
+        api_key="your_api_key",
+        environment="sandbox"  # Use "production" for production environment
+    )
+
+    # Create a card token
+    card_data = {
+        "number": "4111111111111111",
+        "holder_name": "John Doe",
+        "expiration_month": 12,
+        "expiration_year": 2025,
+        "cvv": "123"
+    }
+
+    # Tokenize the card
+    card_token = client.create_card_token(card_data)
+    print("\nCard Token:")
+    print(f"Token ID: {card_token.id}")
+    print(f"Card Brand: {card_token.brand}")
+    print(f"Last Digits: {card_token.last_digits}")
+    print(f"Holder Name: {card_token.holder_name}")
+    print(f"Created at: {card_token.created_at}")
+
+    # Simulate installments
+    amount = 10000  # R$ 100,00
+    installments = client.simulate_installments(amount=amount, brand=card_token.brand)
     
-    # O token pode ser usado para criar uma cobrança
+    print("\nInstallment Options:")
+    for option in installments.installments:
+        print(f"{option.installments}x of R$ {option.amount/100:.2f} "
+              f"(total: R$ {option.total/100:.2f}, interest: {option.interest_rate}%)")
+
+    # Create a charge with the card token
     charge_data = {
-        "amount": 1000,
-        "description": "Teste de cobrança com cartão",
-        "payment_method": "credit_card",
-        "card_token": token_response["id"],
+        "amount": amount,
+        "currency": "BRL",
+        "description": "Example charge with installments",
         "customer": {
-            "name": "João da Silva",
+            "name": "John Doe",
             "tax_id": "123.456.789-00",
-            "email": "joao@exemplo.com"
+            "email": "john@example.com"
+        },
+        "installments": 3,  # 3 installments
+        "metadata": {
+            "order_id": "123",
+            "product_id": "456"
         }
     }
-    
-    charge = client.create_charge(charge_data)
-    print("Cobrança criada com cartão:", charge)
 
-except Exception as e:
-    print("Erro:", str(e)) 
\ No newline at end of file
+    # Create the charge
+    charge = client.charge_with_card_token(card_token.id, charge_data)
+    print("\nCharge:")
+    print(f"ID: {charge.id}")
+    print(f"Amount: R$ {charge.amount/100:.2f}")
+    print(f"Status: {charge.status}")
+    print(f"Customer: {charge.customer.name}")
+    print(f"Created at: {charge.created_at}")
+
+    # Get charge details after a while
+    updated_charge = client.get_charge(charge.id)
+    print(f"\nCharge status: {updated_charge.status}")
+
+    # List refunds for this charge
+    refunds = client.get_charge_refunds(charge.id)
+    if refunds:
+        print("\nRefunds:")
+        for refund in refunds:
+            print(f"- {refund.id}: R$ {refund.amount/100:.2f} ({refund.status})")
+    else:
+        print("\nNo refunds yet")
+
+    # Create a partial refund
+    refund = charge.refund(amount=3000)  # Refund R$ 30,00
+    print("\nPartial Refund:")
+    print(f"ID: {refund.id}")
+    print(f"Amount: R$ {refund.amount/100:.2f}")
+    print(f"Status: {refund.status}")
+    print(f"Created at: {refund.created_at}")
+
+if __name__ == "__main__":
+    main() 
\ No newline at end of file
diff --git a/examples/pix_example.py b/examples/pix_example.py
index ecdef81..dd83929 100644
--- a/examples/pix_example.py
+++ b/examples/pix_example.py
@@ -1,44 +1,64 @@
-from barte import BarteClient
+from barte import BarteClient, PixCharge
 from datetime import datetime, timedelta
 
-# Inicializa o cliente
-client = BarteClient(
-    api_key="sua_api_key_aqui",
-    environment="sandbox"
-)
-
-try:
-    # Criar uma cobrança PIX
-    # Define data de expiração para 24 horas
-    expiration_date = (datetime.utcnow() + timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ")
-    
+def main():
+    # Initialize the client
+    client = BarteClient(
+        api_key="your_api_key",
+        environment="sandbox"  # Use "production" for production environment
+    )
+
+    # Create a PIX charge with expiration
+    expiration = (datetime.utcnow() + timedelta(hours=1)).isoformat()
     pix_data = {
-        "amount": 9990,  # R$ 99,90
-        "description": "Pedido #123 - Loja Virtual",
+        "amount": 15000,  # R$ 150,00
+        "currency": "BRL",
+        "description": "Example PIX charge",
         "customer": {
-            "name": "João da Silva",
+            "name": "John Doe",
             "tax_id": "123.456.789-00",
-            "email": "joao@exemplo.com",
-            "phone": "+5511999999999"
+            "email": "john@example.com"
         },
-        "expiration_date": expiration_date
+        "expiration_date": expiration,
+        "metadata": {
+            "order_id": "123",
+            "product_id": "456"
+        }
     }
-    
-    # Criar a cobrança PIX
-    charge = client.create_pix_charge(pix_data)
-    print("Cobrança PIX criada:", charge)
-    
-    # Obter dados do QR Code
-    charge_id = charge["id"]
-    qr_code_data = client.get_pix_qrcode(charge_id)
-    print("\nDados do QR Code PIX:")
-    print("QR Code:", qr_code_data["qr_code"])
-    print("Imagem do QR Code:", qr_code_data["qr_code_image"])
-    print("PIX Copia e Cola:", qr_code_data["copy_and_paste"])
-    
-    # Monitorar status da cobrança
-    charge_status = client.get_charge(charge_id)
-    print("\nStatus da cobrança:", charge_status["status"])
-
-except Exception as e:
-    print("Erro:", str(e)) 
\ No newline at end of file
+
+    # Create PIX charge
+    pix_charge = client.create_pix_charge(pix_data)
+    print("\nPIX Charge Created:")
+    print(f"ID: {pix_charge.id}")
+    print(f"Amount: R$ {pix_charge.amount/100:.2f}")
+    print(f"Status: {pix_charge.status}")
+    print(f"Customer: {pix_charge.customer.name}")
+    print(f"Created at: {pix_charge.created_at}")
+
+    # Get QR code data
+    pix_charge = pix_charge.get_qr_code()
+    print("\nPIX Payment Information:")
+    print(f"QR Code: {pix_charge.qr_code}")
+    print(f"QR Code Image URL: {pix_charge.qr_code_image}")
+    print(f"Copy and Paste code: {pix_charge.copy_and_paste}")
+
+    # Get charge details after a while
+    updated_charge = client.get_charge(pix_charge.id)
+    print(f"\nCharge status: {updated_charge.status}")
+
+    # List all PIX charges
+    print("\nRecent PIX charges:")
+    charges = client.list_charges({"payment_method": "pix", "limit": 5})
+    for charge in charges:
+        if isinstance(charge, PixCharge):
+            print(f"- {charge.id}: R$ {charge.amount/100:.2f} ({charge.status})")
+
+    # Cancel the charge if still pending
+    if updated_charge.status == "pending":
+        canceled_charge = updated_charge.cancel()
+        print(f"\nCharge canceled: {canceled_charge.status}")
+    else:
+        print(f"\nCharge cannot be canceled: {updated_charge.status}")
+
+if __name__ == "__main__":
+    main() 
\ No newline at end of file
diff --git a/tests/test_client.py b/tests/test_client.py
index 67b2353..a0a2d32 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -1,17 +1,30 @@
 import pytest
+from datetime import datetime
 from unittest.mock import patch, Mock
-from barte import BarteClient
+from barte import BarteClient, Charge, CardToken, Refund, InstallmentOptions, PixCharge
 
 @pytest.fixture
 def barte_client():
-    return BarteClient(api_key="test_key", environment="sandbox")
+    client = BarteClient(api_key="test_key", environment="sandbox")
+    BarteClient._instance = client  # Set instance for model methods
+    return client
 
 @pytest.fixture
-def mock_response():
+def mock_charge_response():
     return {
         "id": "chr_123456789",
         "amount": 1000,
-        "status": "succeeded"
+        "currency": "BRL",
+        "status": "succeeded",
+        "payment_method": "credit_card",
+        "description": "Test charge",
+        "customer": {
+            "name": "John Doe",
+            "tax_id": "123.456.789-00",
+            "email": "john@example.com"
+        },
+        "created_at": "2024-01-07T10:00:00Z",
+        "metadata": {"order_id": "123"}
     }
 
 class TestBarteClient:
@@ -30,9 +43,9 @@ def test_client_initialization(self):
         assert client.headers["Content-Type"] == "application/json"
 
     @patch('requests.post')
-    def test_create_charge(self, mock_post, barte_client, mock_response):
+    def test_create_charge(self, mock_post, barte_client, mock_charge_response):
         """Test creating a new charge"""
-        mock_post.return_value.json.return_value = mock_response
+        mock_post.return_value.json.return_value = mock_charge_response
         mock_post.return_value.raise_for_status = Mock()
 
         charge_data = {
@@ -46,9 +59,14 @@ def test_create_charge(self, mock_post, barte_client, mock_response):
             }
         }
 
-        response = barte_client.create_charge(charge_data)
+        charge = barte_client.create_charge(charge_data)
+        
+        assert isinstance(charge, Charge)
+        assert charge.id == "chr_123456789"
+        assert charge.amount == 1000
+        assert charge.status == "succeeded"
+        assert charge.customer.name == "John Doe"
         
-        assert response == mock_response
         mock_post.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges",
             headers=barte_client.headers,
@@ -56,9 +74,10 @@ def test_create_charge(self, mock_post, barte_client, mock_response):
         )
 
     @patch('requests.post')
-    def test_create_pix_charge(self, mock_post, barte_client, mock_response):
+    def test_create_pix_charge(self, mock_post, barte_client, mock_charge_response):
         """Test creating a PIX charge"""
-        mock_post.return_value.json.return_value = mock_response
+        pix_response = {**mock_charge_response, "payment_method": "pix"}
+        mock_post.return_value.json.return_value = pix_response
         mock_post.return_value.raise_for_status = Mock()
 
         pix_data = {
@@ -71,10 +90,14 @@ def test_create_pix_charge(self, mock_post, barte_client, mock_response):
             }
         }
 
-        response = barte_client.create_pix_charge(pix_data)
+        charge = barte_client.create_pix_charge(pix_data)
+        
+        assert isinstance(charge, PixCharge)
+        assert charge.payment_method == "pix"
+        assert charge.amount == 1000
+        assert charge.customer.name == "John Doe"
         
         expected_data = {**pix_data, "payment_method": "pix"}
-        assert response == mock_response
         mock_post.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges",
             headers=barte_client.headers,
@@ -87,7 +110,12 @@ def test_create_card_token(self, mock_post, barte_client):
         mock_response = {
             "id": "tok_123456",
             "type": "card",
-            "created_at": "2024-03-20T10:00:00Z"
+            "created_at": "2024-03-20T10:00:00Z",
+            "last_digits": "1111",
+            "holder_name": "John Doe",
+            "expiration_month": 12,
+            "expiration_year": 2025,
+            "brand": "visa"
         }
         mock_post.return_value.json.return_value = mock_response
         mock_post.return_value.raise_for_status = Mock()
@@ -100,9 +128,14 @@ def test_create_card_token(self, mock_post, barte_client):
             "cvv": "123"
         }
 
-        response = barte_client.create_card_token(card_data)
+        token = barte_client.create_card_token(card_data)
+        
+        assert isinstance(token, CardToken)
+        assert token.id == "tok_123456"
+        assert token.last_digits == "1111"
+        assert token.holder_name == "John Doe"
+        assert isinstance(token.created_at, datetime)
         
-        assert response == mock_response
         mock_post.assert_called_once_with(
             f"{barte_client.base_url}/v1/tokens",
             headers=barte_client.headers,
@@ -114,17 +147,21 @@ def test_simulate_installments(self, mock_get, barte_client):
         """Test installment simulation"""
         mock_response = {
             "installments": [
-                {"installments": 1, "amount": 1000, "total": 1000},
-                {"installments": 2, "amount": 510, "total": 1020},
-                {"installments": 3, "amount": 345, "total": 1035}
+                {"installments": 1, "amount": 1000, "total": 1000, "interest_rate": 0.0},
+                {"installments": 2, "amount": 510, "total": 1020, "interest_rate": 2.0},
+                {"installments": 3, "amount": 345, "total": 1035, "interest_rate": 3.5}
             ]
         }
         mock_get.return_value.json.return_value = mock_response
         mock_get.return_value.raise_for_status = Mock()
 
-        response = barte_client.simulate_installments(amount=1000, brand="visa")
+        options = barte_client.simulate_installments(amount=1000, brand="visa")
+        
+        assert isinstance(options, InstallmentOptions)
+        assert len(options.installments) == 3
+        assert options.installments[0].amount == 1000
+        assert options.installments[1].interest_rate == 2.0
         
-        assert response == mock_response
         mock_get.assert_called_once_with(
             f"{barte_client.base_url}/v1/simulate/installments",
             headers=barte_client.headers,
@@ -138,15 +175,21 @@ def test_refund_charge(self, mock_post, barte_client):
             "id": "ref_123456",
             "charge_id": "chr_123456789",
             "amount": 1000,
-            "status": "succeeded"
+            "status": "succeeded",
+            "created_at": "2024-01-07T10:00:00Z"
         }
         mock_post.return_value.json.return_value = mock_response
         mock_post.return_value.raise_for_status = Mock()
 
         refund_data = {"amount": 1000}
-        response = barte_client.refund_charge("chr_123456789", refund_data)
+        refund = barte_client.refund_charge("chr_123456789", refund_data)
+        
+        assert isinstance(refund, Refund)
+        assert refund.id == "ref_123456"
+        assert refund.amount == 1000
+        assert refund.status == "succeeded"
+        assert isinstance(refund.created_at, datetime)
         
-        assert response == mock_response
         mock_post.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges/chr_123456789/refund",
             headers=barte_client.headers,
@@ -156,39 +199,45 @@ def test_refund_charge(self, mock_post, barte_client):
     def test_invalid_environment(self):
         """Test initialization with invalid environment"""
         with pytest.raises(ValueError):
-            BarteClient(api_key="test_key", environment="invalid") 
+            BarteClient(api_key="test_key", environment="invalid")
 
     @patch('requests.get')
-    def test_get_charge(self, mock_get, barte_client, mock_response):
+    def test_get_charge(self, mock_get, barte_client, mock_charge_response):
         """Test getting a specific charge"""
-        mock_get.return_value.json.return_value = mock_response
+        mock_get.return_value.json.return_value = mock_charge_response
         mock_get.return_value.raise_for_status = Mock()
 
-        response = barte_client.get_charge("chr_123456789")
+        charge = barte_client.get_charge("chr_123456789")
+        
+        assert isinstance(charge, Charge)
+        assert charge.id == "chr_123456789"
+        assert charge.amount == 1000
+        assert charge.customer.name == "John Doe"
+        assert isinstance(charge.created_at, datetime)
         
-        assert response == mock_response
         mock_get.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges/chr_123456789",
             headers=barte_client.headers
         )
 
     @patch('requests.get')
-    def test_list_charges(self, mock_get, barte_client):
+    def test_list_charges(self, mock_get, barte_client, mock_charge_response):
         """Test listing all charges"""
         mock_response = {
-            "data": [
-                {"id": "chr_1", "amount": 1000},
-                {"id": "chr_2", "amount": 2000}
-            ],
+            "data": [mock_charge_response, {**mock_charge_response, "id": "chr_987654321"}],
             "has_more": False
         }
         mock_get.return_value.json.return_value = mock_response
         mock_get.return_value.raise_for_status = Mock()
 
         params = {"limit": 2, "starting_after": "chr_0"}
-        response = barte_client.list_charges(params)
+        charges = barte_client.list_charges(params)
+        
+        assert len(charges) == 2
+        assert all(isinstance(charge, Charge) for charge in charges)
+        assert charges[0].id == "chr_123456789"
+        assert charges[1].id == "chr_987654321"
         
-        assert response == mock_response
         mock_get.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges",
             headers=barte_client.headers,
@@ -196,207 +245,83 @@ def test_list_charges(self, mock_get, barte_client):
         )
 
     @patch('requests.post')
-    def test_cancel_charge(self, mock_post, barte_client, mock_response):
-        """Test canceling a charge"""
-        mock_post.return_value.json.return_value = mock_response
+    def test_charge_methods(self, mock_post, mock_charge_response):
+        """Test charge instance methods"""
+        # Mock for refund
+        refund_response = {
+            "id": "ref_123456",
+            "charge_id": "chr_123456789",
+            "amount": 500,
+            "status": "succeeded",
+            "created_at": "2024-01-07T10:00:00Z"
+        }
+        mock_post.return_value.json.return_value = refund_response
         mock_post.return_value.raise_for_status = Mock()
 
-        response = barte_client.cancel_charge("chr_123456789")
+        charge = Charge.from_dict(mock_charge_response)
         
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges/chr_123456789/cancel",
-            headers=barte_client.headers
+        # Test refund method
+        refund = charge.refund(amount=500)
+        assert isinstance(refund, Refund)
+        assert refund.amount == 500
+        mock_post.assert_called_with(
+            f"https://sandbox-api.barte.com.br/v1/charges/{charge.id}/refund",
+            headers={"Authorization": "Bearer test_key", "Content-Type": "application/json"},
+            json={"amount": 500}
         )
-
-    @patch('requests.post')
-    def test_charge_with_card_token(self, mock_post, barte_client, mock_response):
-        """Test creating a charge with card token"""
-        mock_post.return_value.json.return_value = mock_response
-        mock_post.return_value.raise_for_status = Mock()
-
-        data = {
-            "amount": 1000,
-            "description": "Test charge with token",
-            "customer": {
-                "name": "John Doe",
-                "tax_id": "123.456.789-00",
-                "email": "john@example.com"
-            },
-            "installments": 1
-        }
-
-        response = barte_client.charge_with_card_token("tok_123456", data)
         
-        expected_data = {
-            **data,
-            "payment_method": "credit_card",
-            "card_token": "tok_123456"
+        # Mock for cancel - use the original mock response with updated status
+        cancel_response = {
+            **mock_charge_response,
+            "status": "canceled"
         }
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges",
-            headers=barte_client.headers,
-            json=expected_data
+        mock_post.return_value.json.return_value = cancel_response
+        
+        # Test cancel method
+        canceled_charge = charge.cancel()
+        assert isinstance(canceled_charge, Charge)
+        assert canceled_charge.status == "canceled"
+        mock_post.assert_called_with(
+            f"https://sandbox-api.barte.com.br/v1/charges/{charge.id}/cancel",
+            headers={"Authorization": "Bearer test_key", "Content-Type": "application/json"}
         )
 
     @patch('requests.get')
-    def test_get_pix_qrcode(self, mock_get, barte_client):
-        """Test getting PIX QR code"""
-        mock_response = {
+    def test_pix_charge_get_qrcode(self, mock_get, mock_charge_response):
+        """Test PIX charge QR code method"""
+        # Create a PIX charge
+        pix_charge = PixCharge.from_dict({**mock_charge_response, "payment_method": "pix"})
+        
+        # Mock QR code response
+        qr_code_response = {
             "qr_code": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000",
             "qr_code_image": "https://api.barte.com.br/v1/qrcodes/123456.png",
             "copy_and_paste": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000"
         }
-        mock_get.return_value.json.return_value = mock_response
+        mock_get.return_value.json.return_value = qr_code_response
         mock_get.return_value.raise_for_status = Mock()
 
-        response = barte_client.get_pix_qrcode("chr_123456789")
+        # Get QR code
+        pix_charge = pix_charge.get_qr_code()
         
-        assert response == mock_response
-        mock_get.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges/chr_123456789/pix",
-            headers=barte_client.headers
-        )
-
-    @patch('requests.post')
-    def test_create_recurring_charge(self, mock_post, barte_client, mock_response):
-        """Test creating a recurring charge"""
-        mock_post.return_value.json.return_value = mock_response
-        mock_post.return_value.raise_for_status = Mock()
-
-        data = {
-            "amount": 5990,
-            "description": "Monthly Subscription",
-            "customer": {
-                "name": "John Doe",
-                "tax_id": "123.456.789-00",
-                "email": "john@example.com"
-            },
-            "card_token": "tok_123456",
-            "recurrence": {
-                "interval": "month",
-                "interval_count": 1
-            }
-        }
-
-        response = barte_client.create_recurring_charge(data)
+        assert isinstance(pix_charge, PixCharge)
+        assert pix_charge.qr_code == qr_code_response["qr_code"]
+        assert pix_charge.qr_code_image == qr_code_response["qr_code_image"]
+        assert pix_charge.copy_and_paste == qr_code_response["copy_and_paste"]
         
-        expected_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "recurring": True
-        }
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges",
-            headers=barte_client.headers,
-            json=expected_data
-        )
-
-    @patch('requests.post')
-    def test_create_installment_charge_with_fee(self, mock_post, barte_client, mock_response):
-        """Test creating an installment charge with customer fees"""
-        mock_post.return_value.json.return_value = mock_response
-        mock_post.return_value.raise_for_status = Mock()
-
-        data = {
-            "amount": 10000,
-            "description": "Installment Purchase",
-            "customer": {
-                "name": "John Doe",
-                "tax_id": "123.456.789-00",
-                "email": "john@example.com"
-            },
-            "card_token": "tok_123456",
-            "installments": 3
-        }
-
-        response = barte_client.create_installment_charge_with_fee(data)
-        
-        expected_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "split_fee": True
-        }
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges",
-            headers=barte_client.headers,
-            json=expected_data
-        )
-
-    @patch('requests.post')
-    def test_create_installment_charge_no_fee(self, mock_post, barte_client, mock_response):
-        """Test creating an installment charge without customer fees"""
-        mock_post.return_value.json.return_value = mock_response
-        mock_post.return_value.raise_for_status = Mock()
-
-        data = {
-            "amount": 10000,
-            "description": "Installment Purchase",
-            "customer": {
-                "name": "John Doe",
-                "tax_id": "123.456.789-00",
-                "email": "john@example.com"
-            },
-            "card_token": "tok_123456",
-            "installments": 3
-        }
-
-        response = barte_client.create_installment_charge_no_fee(data)
-        
-        expected_data = {
-            **data,
-            "payment_method": "credit_card",
-            "capture": True,
-            "split_fee": False
-        }
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges",
-            headers=barte_client.headers,
-            json=expected_data
-        )
-
-    @patch('requests.get')
-    def test_get_charge_refunds(self, mock_get, barte_client):
-        """Test getting charge refunds"""
-        mock_response = {
-            "data": [
-                {
-                    "id": "ref_1",
-                    "charge_id": "chr_123456789",
-                    "amount": 500,
-                    "status": "succeeded"
-                }
-            ],
-            "has_more": False
-        }
-        mock_get.return_value.json.return_value = mock_response
-        mock_get.return_value.raise_for_status = Mock()
-
-        response = barte_client.get_charge_refunds("chr_123456789")
-        
-        assert response == mock_response
         mock_get.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges/chr_123456789/refunds",
-            headers=barte_client.headers
+            f"https://sandbox-api.barte.com.br/v1/charges/{pix_charge.id}/pix",
+            headers={"Authorization": "Bearer test_key", "Content-Type": "application/json"}
         )
 
-    @patch('requests.post')
-    def test_refund_charge_without_data(self, mock_post, barte_client, mock_response):
-        """Test refunding a charge without specifying amount"""
-        mock_post.return_value.json.return_value = mock_response
-        mock_post.return_value.raise_for_status = Mock()
-
-        response = barte_client.refund_charge("chr_123456789")
+    def test_client_singleton(self):
+        """Test client singleton pattern"""
+        # Should raise error when not initialized
+        BarteClient._instance = None
+        with pytest.raises(RuntimeError):
+            BarteClient.get_instance()
         
-        assert response == mock_response
-        mock_post.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges/chr_123456789/refund",
-            headers=barte_client.headers,
-            json={}
-        ) 
\ No newline at end of file
+        # Should return same instance after initialization
+        client1 = BarteClient(api_key="test_key", environment="sandbox")
+        client2 = BarteClient.get_instance()
+        assert client1 is client2 
\ No newline at end of file

From 26fcfa5370697865a38b9deefd5207560ae9b303 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Tue, 7 Jan 2025 23:53:13 -0300
Subject: [PATCH 02/10] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 43f53dd..240d706 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Barte Python SDK
 
-[![Tests](https://github.com/buser-brasil/barte-python-sdk/actions/workflows/tests.yml/badge.svg)](https://github.com/buser-brasil/barte-python-sdk/actions/workflows/tests.yml)
+[![Tests](https://github.com/buserbrasil/barte-python-sdk/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/buserbrasil/barte-python-sdk/actions/workflows/tests.yml)
 [![codecov](https://codecov.io/gh/buser-brasil/barte-python-sdk/branch/main/graph/badge.svg)](https://codecov.io/gh/buser-brasil/barte-python-sdk)
 
 A Python SDK for integrating with the Barte payment platform API. This library provides a simple and efficient way to interact with Barte's payment services, allowing you to process payments, manage transactions, and handle customer data securely.

From 32f9cf7d1a52e7b524f63343d8e381f8ec89f944 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Tue, 7 Jan 2025 23:54:36 -0300
Subject: [PATCH 03/10] gh action: remove codecov

---
 .github/workflows/tests.yml | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 0ac1cca..72f81e7 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -28,9 +28,3 @@ jobs:
     - name: Run tests with pytest
       run: |
         pytest tests/ -v --cov=barte --cov-report=xml
-        
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v4
-      with:
-        file: ./coverage.xml
-        fail_ci_if_error: true 
\ No newline at end of file

From 271b1a4af1bba2917dc98a3e5e16d429343daf5e Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 08:57:40 -0300
Subject: [PATCH 04/10] Update README.md

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 240d706..f01cf34 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,6 @@
 # Barte Python SDK
 
 [![Tests](https://github.com/buserbrasil/barte-python-sdk/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/buserbrasil/barte-python-sdk/actions/workflows/tests.yml)
-[![codecov](https://codecov.io/gh/buser-brasil/barte-python-sdk/branch/main/graph/badge.svg)](https://codecov.io/gh/buser-brasil/barte-python-sdk)
 
 A Python SDK for integrating with the Barte payment platform API. This library provides a simple and efficient way to interact with Barte's payment services, allowing you to process payments, manage transactions, and handle customer data securely.
 

From 6b3db23da0a5d56817d0e4c770217e45852a8049 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 09:46:46 -0300
Subject: [PATCH 05/10] docs: add links to API documentation and integration
 guide

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index f01cf34..e9df074 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,11 @@ card_token = client.create_card_token(
 )
 ```
 
+## Documentation
+
+- [OpenAPI Documentation](https://app.swaggerhub.com/apis-docs/b6782/barte-api/1.0.0#/) - Complete API reference
+- [Integration Guide](https://barte.notion.site/Guia-de-Integra-o-d25d74ee606f4b9ab33efd9e6a4ea22e#460c4da9a5904fc79b789492438bafc4) - Detailed integration guide with examples and best practices
+
 ## Running Tests
 
 To run the test suite, follow these steps:

From 33a9b4561d4c4f7915c466ab052231eb51aa27f1 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 11:48:32 -0300
Subject: [PATCH 06/10] feat: change response to complex object

Change the response from dict to complex object, making it easier to use
the SDK and having better type hints in the IDE.

This change includes:
- Adding PixQRCode model
- Updating client to use complex objects
- Updating tests to handle complex objects
- Adding examples with complex objects

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 barte/__init__.py       |  5 ++++-
 barte/client.py         |  6 +++---
 barte/models.py         | 18 ++++++++++++++----
 examples/pix_example.py | 16 ++++++++++++----
 tests/test_client.py    | 25 ++++++++++++++++++++++++-
 5 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/barte/__init__.py b/barte/__init__.py
index e2f068c..7078fea 100644
--- a/barte/__init__.py
+++ b/barte/__init__.py
@@ -1,4 +1,7 @@
 from .client import BarteClient
-from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge, Customer, InstallmentSimulation
+from .models import (
+    Charge, CardToken, Refund, InstallmentOptions, PixCharge,
+    Customer, InstallmentSimulation, PixQRCode
+)
 
 __version__ = "0.1.0" 
\ No newline at end of file
diff --git a/barte/client.py b/barte/client.py
index 48a528d..e8bc2ea 100644
--- a/barte/client.py
+++ b/barte/client.py
@@ -1,6 +1,6 @@
 from typing import Dict, Any, Optional, List
 import requests
-from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge
+from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge, PixQRCode
 
 class BarteClient:
     VALID_ENVIRONMENTS = ["production", "sandbox"]
@@ -96,12 +96,12 @@ def create_pix_charge(self, data: Dict[str, Any]) -> PixCharge:
         response.raise_for_status()
         return PixCharge.from_dict(response.json())
 
-    def get_pix_qrcode(self, charge_id: str) -> Dict[str, str]:
+    def get_pix_qrcode(self, charge_id: str) -> PixQRCode:
         """Get PIX QR Code data for a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/pix"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return response.json()
+        return PixQRCode.from_dict(response.json())
 
     def simulate_installments(self, amount: int, brand: str) -> InstallmentOptions:
         """Simulate credit card installments"""
diff --git a/barte/models.py b/barte/models.py
index e9df7b9..3e3be62 100644
--- a/barte/models.py
+++ b/barte/models.py
@@ -69,9 +69,9 @@ class PixCharge(Charge):
     def get_qr_code(self) -> "PixCharge":
         from .client import BarteClient
         qr_data = BarteClient.get_instance().get_pix_qrcode(self.id)
-        self.qr_code = qr_data["qr_code"]
-        self.qr_code_image = qr_data["qr_code_image"]
-        self.copy_and_paste = qr_data["copy_and_paste"]
+        self.qr_code = qr_data.qr_code
+        self.qr_code_image = qr_data.qr_code_image
+        self.copy_and_paste = qr_data.copy_and_paste
         return self
 
 @dataclass
@@ -103,4 +103,14 @@ class InstallmentOptions:
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "InstallmentOptions":
         options = [InstallmentSimulation(**item) for item in data["installments"]]
-        return cls(installments=options) 
\ No newline at end of file
+        return cls(installments=options)
+
+@dataclass
+class PixQRCode:
+    qr_code: str
+    qr_code_image: str
+    copy_and_paste: str
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PixQRCode":
+        return cls(**data) 
\ No newline at end of file
diff --git a/examples/pix_example.py b/examples/pix_example.py
index dd83929..2c27d6d 100644
--- a/examples/pix_example.py
+++ b/examples/pix_example.py
@@ -1,4 +1,4 @@
-from barte import BarteClient, PixCharge
+from barte import BarteClient, PixCharge, PixQRCode
 from datetime import datetime, timedelta
 
 def main():
@@ -27,7 +27,7 @@ def main():
     }
 
     # Create PIX charge
-    pix_charge = client.create_pix_charge(pix_data)
+    pix_charge: PixCharge = client.create_pix_charge(pix_data)
     print("\nPIX Charge Created:")
     print(f"ID: {pix_charge.id}")
     print(f"Amount: R$ {pix_charge.amount/100:.2f}")
@@ -36,14 +36,22 @@ def main():
     print(f"Created at: {pix_charge.created_at}")
 
     # Get QR code data
+    # Option 1: Using the charge object method
     pix_charge = pix_charge.get_qr_code()
-    print("\nPIX Payment Information:")
+    print("\nPIX Payment Information (via charge):")
     print(f"QR Code: {pix_charge.qr_code}")
     print(f"QR Code Image URL: {pix_charge.qr_code_image}")
     print(f"Copy and Paste code: {pix_charge.copy_and_paste}")
 
+    # Option 2: Getting QR code directly
+    qr_code: PixQRCode = client.get_pix_qrcode(pix_charge.id)
+    print("\nPIX Payment Information (direct):")
+    print(f"QR Code: {qr_code.qr_code}")
+    print(f"QR Code Image URL: {qr_code.qr_code_image}")
+    print(f"Copy and Paste code: {qr_code.copy_and_paste}")
+
     # Get charge details after a while
-    updated_charge = client.get_charge(pix_charge.id)
+    updated_charge: PixCharge = client.get_charge(pix_charge.id)
     print(f"\nCharge status: {updated_charge.status}")
 
     # List all PIX charges
diff --git a/tests/test_client.py b/tests/test_client.py
index a0a2d32..ea8b880 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -1,7 +1,7 @@
 import pytest
 from datetime import datetime
 from unittest.mock import patch, Mock
-from barte import BarteClient, Charge, CardToken, Refund, InstallmentOptions, PixCharge
+from barte import BarteClient, Charge, CardToken, Refund, InstallmentOptions, PixCharge, PixQRCode
 
 @pytest.fixture
 def barte_client():
@@ -314,6 +314,29 @@ def test_pix_charge_get_qrcode(self, mock_get, mock_charge_response):
             headers={"Authorization": "Bearer test_key", "Content-Type": "application/json"}
         )
 
+    @patch('requests.get')
+    def test_get_pix_qrcode(self, mock_get, barte_client):
+        """Test getting PIX QR code directly"""
+        qr_code_response = {
+            "qr_code": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000",
+            "qr_code_image": "https://api.barte.com.br/v1/qrcodes/123456.png",
+            "copy_and_paste": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000"
+        }
+        mock_get.return_value.json.return_value = qr_code_response
+        mock_get.return_value.raise_for_status = Mock()
+
+        qr_code = barte_client.get_pix_qrcode("chr_123456789")
+        
+        assert isinstance(qr_code, PixQRCode)
+        assert qr_code.qr_code == qr_code_response["qr_code"]
+        assert qr_code.qr_code_image == qr_code_response["qr_code_image"]
+        assert qr_code.copy_and_paste == qr_code_response["copy_and_paste"]
+
+        mock_get.assert_called_once_with(
+            f"{barte_client.base_url}/v1/charges/chr_123456789/pix",
+            headers=barte_client.headers
+        )
+
     def test_client_singleton(self):
         """Test client singleton pattern"""
         # Should raise error when not initialized

From cea76338f7854f89eb3bac592a04504d4b4ebc8a Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 11:50:45 -0300
Subject: [PATCH 07/10] feat: achieved 100% test coverage

Added tests for all BarteClient class methods,
ensuring complete code coverage.

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 barte/models.py      |   2 +
 tests/test_client.py | 147 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 148 insertions(+), 1 deletion(-)

diff --git a/barte/models.py b/barte/models.py
index 3e3be62..6d72b37 100644
--- a/barte/models.py
+++ b/barte/models.py
@@ -36,6 +36,8 @@ class Charge:
     customer: Customer
     created_at: datetime
     metadata: Optional[Dict[str, Any]] = None
+    installments: Optional[int] = None
+    installment_amount: Optional[int] = None
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "Charge":
diff --git a/tests/test_client.py b/tests/test_client.py
index ea8b880..bc190fa 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -347,4 +347,149 @@ def test_client_singleton(self):
         # Should return same instance after initialization
         client1 = BarteClient(api_key="test_key", environment="sandbox")
         client2 = BarteClient.get_instance()
-        assert client1 is client2 
\ No newline at end of file
+        assert client1 is client2 
+
+    @patch('requests.post')
+    def test_charge_with_card_token(self, mock_post, barte_client, mock_charge_response):
+        """Test creating a charge with card token"""
+        mock_post.return_value.json.return_value = mock_charge_response
+        mock_post.return_value.raise_for_status = Mock()
+
+        token_id = "tok_123456"
+        charge_data = {
+            "amount": 1000,
+            "description": "Test charge with token",
+            "customer": {
+                "name": "John Doe",
+                "tax_id": "123.456.789-00",
+                "email": "john@example.com"
+            },
+            "metadata": {
+                "order_id": "123"
+            }
+        }
+
+        charge = barte_client.charge_with_card_token(token_id, charge_data)
+        
+        assert isinstance(charge, Charge)
+        assert charge.id == "chr_123456789"
+        assert charge.amount == 1000
+        assert charge.payment_method == "credit_card"
+        assert charge.customer.name == "John Doe"
+        
+        expected_data = {
+            **charge_data,
+            "payment_method": "credit_card",
+            "card_token": token_id
+        }
+        mock_post.assert_called_once_with(
+            f"{barte_client.base_url}/v1/charges",
+            headers=barte_client.headers,
+            json=expected_data
+        )
+
+    @patch('requests.get')
+    def test_get_charge_refunds(self, mock_get, barte_client):
+        """Test getting refunds for a charge"""
+        mock_response = {
+            "data": [
+                {
+                    "id": "ref_123456",
+                    "charge_id": "chr_123456789",
+                    "amount": 500,
+                    "status": "succeeded",
+                    "created_at": "2024-01-07T10:00:00Z"
+                },
+                {
+                    "id": "ref_789012",
+                    "charge_id": "chr_123456789",
+                    "amount": 500,
+                    "status": "succeeded",
+                    "created_at": "2024-01-07T11:00:00Z"
+                }
+            ]
+        }
+        mock_get.return_value.json.return_value = mock_response
+        mock_get.return_value.raise_for_status = Mock()
+
+        refunds = barte_client.get_charge_refunds("chr_123456789")
+        
+        assert len(refunds) == 2
+        assert all(isinstance(refund, Refund) for refund in refunds)
+        
+        # Test first refund
+        assert refunds[0].id == "ref_123456"
+        assert refunds[0].amount == 500
+        assert refunds[0].status == "succeeded"
+        assert isinstance(refunds[0].created_at, datetime)
+        
+        # Test second refund
+        assert refunds[1].id == "ref_789012"
+        assert refunds[1].amount == 500
+        assert refunds[1].status == "succeeded"
+        assert isinstance(refunds[1].created_at, datetime)
+        
+        mock_get.assert_called_once_with(
+            f"{barte_client.base_url}/v1/charges/chr_123456789/refunds",
+            headers=barte_client.headers
+        )
+
+    @patch('requests.get')
+    def test_get_charge_refunds_empty(self, mock_get, barte_client):
+        """Test getting refunds for a charge with no refunds"""
+        mock_response = {"data": []}
+        mock_get.return_value.json.return_value = mock_response
+        mock_get.return_value.raise_for_status = Mock()
+
+        refunds = barte_client.get_charge_refunds("chr_123456789")
+        
+        assert len(refunds) == 0
+        assert isinstance(refunds, list)
+        
+        mock_get.assert_called_once_with(
+            f"{barte_client.base_url}/v1/charges/chr_123456789/refunds",
+            headers=barte_client.headers
+        )
+
+    @patch('requests.post')
+    def test_charge_with_card_token_with_installments(self, mock_post, barte_client, mock_charge_response):
+        """Test creating a charge with card token and installments"""
+        response_with_installments = {
+            **mock_charge_response,
+            "installments": 3,
+            "installment_amount": 333
+        }
+        mock_post.return_value.json.return_value = response_with_installments
+        mock_post.return_value.raise_for_status = Mock()
+
+        token_id = "tok_123456"
+        charge_data = {
+            "amount": 1000,
+            "description": "Test charge with installments",
+            "customer": {
+                "name": "John Doe",
+                "tax_id": "123.456.789-00",
+                "email": "john@example.com"
+            },
+            "installments": 3
+        }
+
+        charge = barte_client.charge_with_card_token(token_id, charge_data)
+        
+        assert isinstance(charge, Charge)
+        assert charge.id == "chr_123456789"
+        assert charge.amount == 1000
+        assert charge.payment_method == "credit_card"
+        assert charge.installments == 3
+        assert charge.installment_amount == 333
+        
+        expected_data = {
+            **charge_data,
+            "payment_method": "credit_card",
+            "card_token": token_id
+        }
+        mock_post.assert_called_once_with(
+            f"{barte_client.base_url}/v1/charges",
+            headers=barte_client.headers,
+            json=expected_data
+        ) 
\ No newline at end of file

From 4fd21001fbdf86b9d2525b0380af57222478d0fe Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 17:46:43 -0300
Subject: [PATCH 08/10] refactor: change from_dict to dacite lib

- change from_dict to dacite lib
- add dacite config to handle datetime
- add dacite config to handle list of installment simulation

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 barte/client.py      |  33 ++++++++------
 barte/models.py      |  46 ++++----------------
 setup.py             |   3 +-
 tests/test_client.py | 100 ++++++++++++++++---------------------------
 4 files changed, 68 insertions(+), 114 deletions(-)

diff --git a/barte/client.py b/barte/client.py
index e8bc2ea..0cbfbe9 100644
--- a/barte/client.py
+++ b/barte/client.py
@@ -1,6 +1,11 @@
 from typing import Dict, Any, Optional, List
 import requests
-from .models import Charge, CardToken, Refund, InstallmentOptions, PixCharge, PixQRCode
+from dacite import from_dict
+from .models import (
+    Charge, CardToken, Refund, InstallmentOptions,
+    PixCharge, PixQRCode, DACITE_CONFIG, Config,
+    InstallmentSimulation
+)
 
 class BarteClient:
     VALID_ENVIRONMENTS = ["production", "sandbox"]
@@ -39,35 +44,35 @@ def create_charge(self, data: Dict[str, Any]) -> Charge:
         endpoint = f"{self.base_url}/v1/charges"
         response = requests.post(endpoint, headers=self.headers, json=data)
         response.raise_for_status()
-        return Charge.from_dict(response.json())
+        return from_dict(data_class=Charge, data=response.json(), config=DACITE_CONFIG)
 
     def get_charge(self, charge_id: str) -> Charge:
         """Get a specific charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return Charge.from_dict(response.json())
+        return from_dict(data_class=Charge, data=response.json(), config=DACITE_CONFIG)
 
     def list_charges(self, params: Optional[Dict[str, Any]] = None) -> List[Charge]:
         """List all charges with optional filters"""
         endpoint = f"{self.base_url}/v1/charges"
         response = requests.get(endpoint, headers=self.headers, params=params)
         response.raise_for_status()
-        return [Charge.from_dict(item) for item in response.json()["data"]]
+        return [from_dict(data_class=Charge, data=item, config=DACITE_CONFIG) for item in response.json()["data"]]
 
     def cancel_charge(self, charge_id: str) -> Charge:
         """Cancel a specific charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/cancel"
         response = requests.post(endpoint, headers=self.headers)
         response.raise_for_status()
-        return Charge.from_dict(response.json())
+        return from_dict(data_class=Charge, data=response.json(), config=DACITE_CONFIG)
 
     def create_card_token(self, card_data: Dict[str, Any]) -> CardToken:
         """Create a token for a credit card"""
         endpoint = f"{self.base_url}/v1/tokens"
         response = requests.post(endpoint, headers=self.headers, json=card_data)
         response.raise_for_status()
-        return CardToken.from_dict(response.json())
+        return from_dict(data_class=CardToken, data=response.json(), config=DACITE_CONFIG)
 
     def charge_with_card_token(self, token_id: str, data: Dict[str, Any]) -> Charge:
         """Create a charge using an existing card token"""
@@ -81,7 +86,7 @@ def charge_with_card_token(self, token_id: str, data: Dict[str, Any]) -> Charge:
         
         response = requests.post(endpoint, headers=self.headers, json=transaction_data)
         response.raise_for_status()
-        return Charge.from_dict(response.json())
+        return from_dict(data_class=Charge, data=response.json(), config=DACITE_CONFIG)
 
     def create_pix_charge(self, data: Dict[str, Any]) -> PixCharge:
         """Create a PIX charge"""
@@ -94,14 +99,14 @@ def create_pix_charge(self, data: Dict[str, Any]) -> PixCharge:
         
         response = requests.post(endpoint, headers=self.headers, json=pix_data)
         response.raise_for_status()
-        return PixCharge.from_dict(response.json())
+        return from_dict(data_class=PixCharge, data=response.json(), config=DACITE_CONFIG)
 
     def get_pix_qrcode(self, charge_id: str) -> PixQRCode:
         """Get PIX QR Code data for a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/pix"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return PixQRCode.from_dict(response.json())
+        return from_dict(data_class=PixQRCode, data=response.json())
 
     def simulate_installments(self, amount: int, brand: str) -> InstallmentOptions:
         """Simulate credit card installments"""
@@ -109,18 +114,22 @@ def simulate_installments(self, amount: int, brand: str) -> InstallmentOptions:
         params = {"amount": amount, "brand": brand}
         response = requests.get(endpoint, headers=self.headers, params=params)
         response.raise_for_status()
-        return InstallmentOptions.from_dict(response.json())
+        return from_dict(
+            data_class=InstallmentOptions,
+            data=response.json(),
+            config=Config(cast=[List[InstallmentSimulation]])
+        )
 
     def get_charge_refunds(self, charge_id: str) -> List[Refund]:
         """Get all refunds for a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/refunds"
         response = requests.get(endpoint, headers=self.headers)
         response.raise_for_status()
-        return [Refund.from_dict(item) for item in response.json()["data"]]
+        return [from_dict(data_class=Refund, data=item, config=DACITE_CONFIG) for item in response.json()["data"]]
 
     def refund_charge(self, charge_id: str, data: Optional[Dict[str, Any]] = None) -> Refund:
         """Refund a charge"""
         endpoint = f"{self.base_url}/v1/charges/{charge_id}/refund"
         response = requests.post(endpoint, headers=self.headers, json=data or {})
         response.raise_for_status()
-        return Refund.from_dict(response.json()) 
\ No newline at end of file
+        return from_dict(data_class=Refund, data=response.json(), config=DACITE_CONFIG) 
\ No newline at end of file
diff --git a/barte/models.py b/barte/models.py
index 6d72b37..9f4f3c5 100644
--- a/barte/models.py
+++ b/barte/models.py
@@ -1,6 +1,14 @@
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional, List, Dict, Any
+from dacite import Config
+
+# Default config for dacite with datetime conversion
+DACITE_CONFIG = Config(
+    type_hooks={
+        datetime: lambda x: datetime.fromisoformat(x.replace("Z", "+00:00")) if isinstance(x, str) else x
+    }
+)
 
 @dataclass
 class Customer:
@@ -19,12 +27,6 @@ class CardToken:
     expiration_year: int
     brand: str
 
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "CardToken":
-        if isinstance(data["created_at"], str):
-            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
-        return cls(**data)
-
 @dataclass
 class Charge:
     id: str
@@ -39,21 +41,6 @@ class Charge:
     installments: Optional[int] = None
     installment_amount: Optional[int] = None
 
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Charge":
-        # Copy data to avoid modifying the original
-        data = data.copy()
-        
-        # Convert customer if it's a dict
-        if isinstance(data["customer"], dict):
-            data["customer"] = Customer(**data["customer"])
-        
-        # Convert created_at if it's a string
-        if isinstance(data["created_at"], str):
-            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
-        
-        return cls(**data)
-
     def refund(self, amount: Optional[int] = None) -> "Refund":
         from .client import BarteClient
         return BarteClient.get_instance().refund_charge(self.id, {"amount": amount} if amount else None)
@@ -85,12 +72,6 @@ class Refund:
     created_at: datetime
     metadata: Optional[Dict[str, Any]] = None
 
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Refund":
-        if isinstance(data["created_at"], str):
-            data["created_at"] = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00"))
-        return cls(**data)
-
 @dataclass
 class InstallmentSimulation:
     installments: int
@@ -102,17 +83,8 @@ class InstallmentSimulation:
 class InstallmentOptions:
     installments: List[InstallmentSimulation]
 
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "InstallmentOptions":
-        options = [InstallmentSimulation(**item) for item in data["installments"]]
-        return cls(installments=options)
-
 @dataclass
 class PixQRCode:
     qr_code: str
     qr_code_image: str
-    copy_and_paste: str
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PixQRCode":
-        return cls(**data) 
\ No newline at end of file
+    copy_and_paste: str 
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 439f185..f1827d5 100644
--- a/setup.py
+++ b/setup.py
@@ -8,7 +8,8 @@
     author_email="thiago.avelino@buser.com.br",
     packages=find_packages(),
     install_requires=[
-        "requests>=2.25.0"
+        "requests>=2.25.0",
+        "dacite>=1.8.0"
     ],
     python_requires=">=3.10",
     classifiers=[
diff --git a/tests/test_client.py b/tests/test_client.py
index bc190fa..ad1ca98 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -1,7 +1,9 @@
 import pytest
 from datetime import datetime
 from unittest.mock import patch, Mock
+from dacite import from_dict
 from barte import BarteClient, Charge, CardToken, Refund, InstallmentOptions, PixCharge, PixQRCode
+from barte.models import DACITE_CONFIG
 
 @pytest.fixture
 def barte_client():
@@ -29,18 +31,20 @@ def mock_charge_response():
 
 class TestBarteClient:
     def test_client_initialization(self):
-        """Test client initialization with different environments"""
-        # Production environment
-        client = BarteClient(api_key="test_key", environment="production")
-        assert client.base_url == "https://api.barte.com.br"
-        
-        # Sandbox environment
+        """Test client initialization with valid environment"""
         client = BarteClient(api_key="test_key", environment="sandbox")
+        assert client.api_key == "test_key"
         assert client.base_url == "https://sandbox-api.barte.com.br"
-        
-        # Check headers
-        assert client.headers["Authorization"] == "Bearer test_key"
-        assert client.headers["Content-Type"] == "application/json"
+        assert client.headers == {
+            "Authorization": "Bearer test_key",
+            "Content-Type": "application/json"
+        }
+
+    def test_invalid_environment(self):
+        """Test client initialization with invalid environment"""
+        with pytest.raises(ValueError) as exc_info:
+            BarteClient(api_key="test_key", environment="invalid")
+        assert "Invalid environment" in str(exc_info.value)
 
     @patch('requests.post')
     def test_create_charge(self, mock_post, barte_client, mock_charge_response):
@@ -62,10 +66,10 @@ def test_create_charge(self, mock_post, barte_client, mock_charge_response):
         charge = barte_client.create_charge(charge_data)
         
         assert isinstance(charge, Charge)
-        assert charge.id == "chr_123456789"
         assert charge.amount == 1000
-        assert charge.status == "succeeded"
         assert charge.customer.name == "John Doe"
+        assert charge.metadata == {"order_id": "123"}
+        assert isinstance(charge.created_at, datetime)
         
         mock_post.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges",
@@ -196,11 +200,6 @@ def test_refund_charge(self, mock_post, barte_client):
             json=refund_data
         )
 
-    def test_invalid_environment(self):
-        """Test initialization with invalid environment"""
-        with pytest.raises(ValueError):
-            BarteClient(api_key="test_key", environment="invalid")
-
     @patch('requests.get')
     def test_get_charge(self, mock_get, barte_client, mock_charge_response):
         """Test getting a specific charge"""
@@ -237,6 +236,7 @@ def test_list_charges(self, mock_get, barte_client, mock_charge_response):
         assert all(isinstance(charge, Charge) for charge in charges)
         assert charges[0].id == "chr_123456789"
         assert charges[1].id == "chr_987654321"
+        assert all(isinstance(charge.created_at, datetime) for charge in charges)
         
         mock_get.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges",
@@ -258,7 +258,7 @@ def test_charge_methods(self, mock_post, mock_charge_response):
         mock_post.return_value.json.return_value = refund_response
         mock_post.return_value.raise_for_status = Mock()
 
-        charge = Charge.from_dict(mock_charge_response)
+        charge = from_dict(data_class=Charge, data=mock_charge_response, config=DACITE_CONFIG)
         
         # Test refund method
         refund = charge.refund(amount=500)
@@ -290,7 +290,7 @@ def test_charge_methods(self, mock_post, mock_charge_response):
     def test_pix_charge_get_qrcode(self, mock_get, mock_charge_response):
         """Test PIX charge QR code method"""
         # Create a PIX charge
-        pix_charge = PixCharge.from_dict({**mock_charge_response, "payment_method": "pix"})
+        pix_charge = from_dict(data_class=PixCharge, data={**mock_charge_response, "payment_method": "pix"}, config=DACITE_CONFIG)
         
         # Mock QR code response
         qr_code_response = {
@@ -314,40 +314,19 @@ def test_pix_charge_get_qrcode(self, mock_get, mock_charge_response):
             headers={"Authorization": "Bearer test_key", "Content-Type": "application/json"}
         )
 
-    @patch('requests.get')
-    def test_get_pix_qrcode(self, mock_get, barte_client):
-        """Test getting PIX QR code directly"""
-        qr_code_response = {
-            "qr_code": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000",
-            "qr_code_image": "https://api.barte.com.br/v1/qrcodes/123456.png",
-            "copy_and_paste": "00020126580014br.gov.bcb.pix0136123e4567-e89b-12d3-a456-426614174000"
-        }
-        mock_get.return_value.json.return_value = qr_code_response
-        mock_get.return_value.raise_for_status = Mock()
-
-        qr_code = barte_client.get_pix_qrcode("chr_123456789")
-        
-        assert isinstance(qr_code, PixQRCode)
-        assert qr_code.qr_code == qr_code_response["qr_code"]
-        assert qr_code.qr_code_image == qr_code_response["qr_code_image"]
-        assert qr_code.copy_and_paste == qr_code_response["copy_and_paste"]
-
-        mock_get.assert_called_once_with(
-            f"{barte_client.base_url}/v1/charges/chr_123456789/pix",
-            headers=barte_client.headers
-        )
-
     def test_client_singleton(self):
         """Test client singleton pattern"""
-        # Should raise error when not initialized
-        BarteClient._instance = None
-        with pytest.raises(RuntimeError):
-            BarteClient.get_instance()
-        
-        # Should return same instance after initialization
+        # First initialization
         client1 = BarteClient(api_key="test_key", environment="sandbox")
-        client2 = BarteClient.get_instance()
-        assert client1 is client2 
+        assert BarteClient.get_instance() == client1
+
+        # Second initialization
+        client2 = BarteClient(api_key="another_key", environment="sandbox")
+        assert BarteClient.get_instance() == client2
+        assert client2.api_key == "another_key"
+
+        # Reset singleton for other tests
+        BarteClient._instance = None
 
     @patch('requests.post')
     def test_charge_with_card_token(self, mock_post, barte_client, mock_charge_response):
@@ -372,10 +351,10 @@ def test_charge_with_card_token(self, mock_post, barte_client, mock_charge_respo
         charge = barte_client.charge_with_card_token(token_id, charge_data)
         
         assert isinstance(charge, Charge)
-        assert charge.id == "chr_123456789"
         assert charge.amount == 1000
-        assert charge.payment_method == "credit_card"
         assert charge.customer.name == "John Doe"
+        assert charge.metadata == {"order_id": "123"}
+        assert isinstance(charge.created_at, datetime)
         
         expected_data = {
             **charge_data,
@@ -405,7 +384,7 @@ def test_get_charge_refunds(self, mock_get, barte_client):
                     "charge_id": "chr_123456789",
                     "amount": 500,
                     "status": "succeeded",
-                    "created_at": "2024-01-07T11:00:00Z"
+                    "created_at": "2024-01-07T10:30:00Z"
                 }
             ]
         }
@@ -416,18 +395,11 @@ def test_get_charge_refunds(self, mock_get, barte_client):
         
         assert len(refunds) == 2
         assert all(isinstance(refund, Refund) for refund in refunds)
-        
-        # Test first refund
         assert refunds[0].id == "ref_123456"
-        assert refunds[0].amount == 500
-        assert refunds[0].status == "succeeded"
-        assert isinstance(refunds[0].created_at, datetime)
-        
-        # Test second refund
         assert refunds[1].id == "ref_789012"
-        assert refunds[1].amount == 500
+        assert refunds[0].amount == 500
         assert refunds[1].status == "succeeded"
-        assert isinstance(refunds[1].created_at, datetime)
+        assert all(isinstance(refund.created_at, datetime) for refund in refunds)
         
         mock_get.assert_called_once_with(
             f"{barte_client.base_url}/v1/charges/chr_123456789/refunds",
@@ -477,11 +449,11 @@ def test_charge_with_card_token_with_installments(self, mock_post, barte_client,
         charge = barte_client.charge_with_card_token(token_id, charge_data)
         
         assert isinstance(charge, Charge)
-        assert charge.id == "chr_123456789"
         assert charge.amount == 1000
-        assert charge.payment_method == "credit_card"
         assert charge.installments == 3
         assert charge.installment_amount == 333
+        assert charge.customer.name == "John Doe"
+        assert isinstance(charge.created_at, datetime)
         
         expected_data = {
             **charge_data,

From 5a4b3b6ba47905c8369cfbf84374fceea3a6ddc2 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 17:48:45 -0300
Subject: [PATCH 09/10] chore: drop support for Python 3.10

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 .github/workflows/tests.yml | 2 +-
 setup.py                    | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 72f81e7..f8fb78b 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v4
diff --git a/setup.py b/setup.py
index f1827d5..48954a4 100644
--- a/setup.py
+++ b/setup.py
@@ -11,10 +11,9 @@
         "requests>=2.25.0",
         "dacite>=1.8.0"
     ],
-    python_requires=">=3.10",
+    python_requires=">=3.11",
     classifiers=[
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
     ],

From 688b3b6a14800e8760b251982acf93c183e4ec66 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Wed, 8 Jan 2025 18:01:17 -0300
Subject: [PATCH 10/10] feat: change datetime parser to use python-dateutil

The datetime parser in DACITE_CONFIG has been updated to use python-dateutil's parse function instead of datetime.fromisoformat. This change provides more robust datetime parsing capabilities and better handles various datetime string formats.

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 barte/models.py      | 3 ++-
 requirements-dev.txt | 3 ++-
 setup.py             | 3 ++-
 tests/test_client.py | 8 ++++++++
 4 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/barte/models.py b/barte/models.py
index 9f4f3c5..6aa7aae 100644
--- a/barte/models.py
+++ b/barte/models.py
@@ -2,11 +2,12 @@
 from datetime import datetime
 from typing import Optional, List, Dict, Any
 from dacite import Config
+from dateutil.parser import parse as parse_date
 
 # Default config for dacite with datetime conversion
 DACITE_CONFIG = Config(
     type_hooks={
-        datetime: lambda x: datetime.fromisoformat(x.replace("Z", "+00:00")) if isinstance(x, str) else x
+        datetime: lambda x: parse_date(x) if isinstance(x, str) else x
     }
 )
 
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 6dc16e9..4abcdde 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,3 +1,4 @@
 pytest>=7.0.0
 pytest-cov>=4.0.0
-requests-mock>=1.10.0 
\ No newline at end of file
+requests-mock>=1.10.0 
+python-dateutil>=2.8.0
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 48954a4..b866ad7 100644
--- a/setup.py
+++ b/setup.py
@@ -9,7 +9,8 @@
     packages=find_packages(),
     install_requires=[
         "requests>=2.25.0",
-        "dacite>=1.8.0"
+        "dacite>=1.8.0",
+        "python-dateutil>=2.8.0"
     ],
     python_requires=">=3.11",
     classifiers=[
diff --git a/tests/test_client.py b/tests/test_client.py
index ad1ca98..7800c16 100644
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -316,6 +316,14 @@ def test_pix_charge_get_qrcode(self, mock_get, mock_charge_response):
 
     def test_client_singleton(self):
         """Test client singleton pattern"""
+        # Reset singleton for initial state
+        BarteClient._instance = None
+
+        # Test uninitialized state
+        with pytest.raises(RuntimeError) as exc_info:
+            BarteClient.get_instance()
+        assert "BarteClient not initialized" in str(exc_info.value)
+
         # First initialization
         client1 = BarteClient(api_key="test_key", environment="sandbox")
         assert BarteClient.get_instance() == client1