fix examples

Author: adriangalilea

examples/check_domain.py

@@ -10,7 +10,7 @@
 import argparse
 
 from namecheap import NamecheapClient
-from utils.print_table import print_table
+from examples.utils.print_table import print_table
 
 # Parse command line arguments
 parser = argparse.ArgumentParser(
@@ -23,20 +23,22 @@
 
 # Create the Namecheap client and check domain availability
 client = NamecheapClient(
-    api_user="default",
-    api_key="default",
-    username="default",
-    client_ip="default",
     debug=args.debug,
+    load_env=True  # Load values from .env file
 )
 result = client.enhanced.domains.check_with_pricing(args.domains)
 
+if args.debug:
+    import json
+    print("\nRaw API response structure:")
+    print(json.dumps(result, indent=2, default=str))
+
 # Prepare table data
 headers = ["Domain", "Available", "Premium", "Price"]
 rows = []
 
-# The result now contains a DomainCheckResult key with a list of domain results
-domains = result["DomainCheckResult"]
+# The result contains a DomainCheckResult key with a list of domain results
+domains = result.get("DomainCheckResult", [])
 
 for domain in domains:
     available = "Yes" if domain.get("Available") else "No"

examples/dns_tool.py

@@ -76,8 +76,7 @@ def list_records(
 
         # Get records now returns a clean list of normalized records
         records = client.domains.dns.get_hosts(domain)
-        return records
-
+        
         if client.debug:
             print(f"\nFound {len(records)} DNS records")
 
@@ -95,11 +94,11 @@ def list_records(
 
         for record in records:
             # Use the original API field names
-            name = record["Name"]
-            record_type = record["Type"]
-            ttl = record["TTL"]
-            mx_pref = record["MXPref"] if record_type == "MX" else ""
-            address = record["Address"]
+            name = record.get("Name", "")
+            record_type = record.get("Type", "")
+            ttl = record.get("TTL", "")
+            mx_pref = record.get("MXPref", "") if record_type == "MX" else ""
+            address = record.get("Address", "")
 
             rows.append(
                 [str(name), str(record_type), str(ttl), str(mx_pref), str(address)]
@@ -108,6 +107,8 @@ def list_records(
         # Print table
         print(f"\nDNS Records for {domain}:")
         print_table(headers, rows)
+        
+        return records
 
     except NamecheapException as e:
         print(e)
@@ -154,12 +155,12 @@ def add_record(
         # Update the records
         result = client.domains.dns.set_hosts(domain, updated_records)
 
-        if result["success"]:
+        # Check for success based on IsSuccess field which is normalized to "IsSuccess"
+        if result.get("IsSuccess", False):
             print(f"\nSuccess! Record added to {domain}")
         else:
-            print(
-                f"\nWarning: Operation completed but with warnings: {result['warnings']}"
-            )
+            warnings = result.get("Warnings", "")
+            print(f"\nWarning: Operation completed but with warnings: {warnings}")
 
     except NamecheapException as e:
         print(e)
@@ -219,13 +220,15 @@ def delete_record(
         # Update records (removing the ones to delete)
         result = client.domains.dns.set_hosts(domain, records_to_keep)
 
-        if result["success"]:
+        # Check for success based on IsSuccess field 
+        if result.get("IsSuccess", False):
             print(
                 f"\nSuccess! {len(records_to_delete)} record(s) deleted from {domain}"
             )
         else:
+            warnings = result.get("Warnings", "")
             print(
-                f"\nWarning: Operation completed but with warnings: {result['warnings']}"
+                f"\nWarning: Operation completed but with warnings: {warnings}"
             )
 
     except NamecheapException as e:
@@ -385,13 +388,10 @@ def main() -> None:
 
     args = parser.parse_args()
 
-    # Initialize client with debug mode using the args object
+    # Initialize client with debug mode and load credentials from environment variables
     client = NamecheapClient(
-        api_user="default",
-        api_key="default",
-        username="default",
-        client_ip="default",
         debug=args.debug,
+        load_env=True
     )
 
     # Execute the appropriate command

namecheap/api/domains/base.py

@@ -170,7 +170,10 @@ def check(self, domains: List[str]) -> List[Dict[str, object]]:
 
         # Use the normalize_api_response method to get results
         results = self.client.normalize_api_response(
-            response=response, result_key="DomainCheckResult", return_type="list"
+            response=response, 
+            result_key="DomainCheckResult", 
+            boolean_fields=["Available", "IsPremiumName"],
+            return_type="list"
         )
 
         # Results are now properly typed as ResponseList (List[Dict[str, object]])

namecheap/api/users/base.py

@@ -2,7 +2,10 @@
 Users API operations
 """
 
-from typing import Any, List, Optional, TypedDict
+from typing import Any, List, Optional, TypedDict, Union
+
+# Import ResponseDict type from base module for type annotations
+from ...base import ResponseDict
 
 
 # TypedDict definitions for user operations
@@ -87,8 +90,8 @@ def get_pricing(
         product_category: Optional[str] = None,
         promotion_code: Optional[str] = None,
         action_name: Optional[str] = None,
-        product_name: Optional[List[str]] = None,
-    ) -> PricingResult:
+        product_name: Optional[Union[str, List[str]]] = None,
+    ) -> ResponseDict:
         """
         Get pricing information for Namecheap products
 
@@ -103,10 +106,10 @@ def get_pricing(
             product_category: Product category (REGISTER, RENEW, REACTIVATE, TRANSFER, WHOISGUARD)
             promotion_code: Promotional (coupon) code for the product
             action_name: Name of the action (REGISTER, RENEW, REACTIVATE, TRANSFER, WHOISGUARD)
-            product_name: List of product names (e.g., [".com", ".net"] for domains)
+            product_name: List or single product name (e.g., ".com" or [".com", ".net"] for domains)
 
         Returns:
-            Dictionary with pricing information
+            Raw response dictionary directly from the API with complete XML structure preserved
 
         Raises:
             ValueError: If parameters are invalid
@@ -169,75 +172,17 @@ def get_pricing(
                 params["ProductName"] = product_name
 
         # Make the API call with centralized error handling
+        # This returns the raw CommandResponse section from the API response
         response = self.client._make_request(
             "namecheap.users.getPricing",
             params,
             error_codes,
             {"product_type": product_type},
         )
 
-        # Parse the response into a properly typed result
-        product_list: List[ProductPrice] = []
-
-        # Extract products from the response
-        if "ProductType" in response and "ProductCategory" in response.get(
-            "ProductType", {}
-        ):
-            categories = response["ProductType"]["ProductCategory"]
-            if not isinstance(categories, list):
-                categories = [categories]
-
-            for category in categories:
-                if "Product" in category:
-                    products = category["Product"]
-                    if not isinstance(products, list):
-                        products = [products]
-
-                    for product in products:
-                        if isinstance(product, dict):
-                            product_price: ProductPrice = {
-                                "ProductName": product.get("Name", ""),
-                                "Currency": product.get("Currency", "USD"),
-                            }
-
-                            # Add prices if available
-                            if "Price" in product:
-                                product_price["Price"] = float(product["Price"])
-
-                            # Add specific price types if available
-                            if "RegisterPrice" in product:
-                                product_price["RegisterPrice"] = float(
-                                    product["RegisterPrice"]
-                                )
-                            if "RenewPrice" in product:
-                                product_price["RenewPrice"] = float(
-                                    product["RenewPrice"]
-                                )
-                            if "TransferPrice" in product:
-                                product_price["TransferPrice"] = float(
-                                    product["TransferPrice"]
-                                )
-                            if "RestorePrice" in product:
-                                product_price["RestorePrice"] = float(
-                                    product["RestorePrice"]
-                                )
-                            if "ReactivatePrice" in product:
-                                product_price["ReactivatePrice"] = float(
-                                    product["ReactivatePrice"]
-                                )
-
-                            product_list.append(product_price)
-
-        # Create the typed result
-        result: PricingResult = {
-            "products": product_list,
-            "currency": response.get("Currency", "USD"),
-            "product_type": product_type,
-            "category": product_category,
-            "promotion_code": promotion_code,
-        }
-
-        return result
+        # Return the raw response to allow enhanced methods to parse it according to their needs
+        # This preserves the original XML structure mapping
+        return response
 
     def get_balances(self) -> AccountBalance:
         """