namecheap-python 1.3.0__tar.gz → 1.5.0__tar.gz

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/CONTRIBUTING.md

@@ -54,7 +54,9 @@ src/
 │   └── _api/               # API implementations
 │       ├── base.py         # BaseAPI with _request() — all API calls go through here
 │       ├── domains.py      # namecheap.domains.* endpoints
-│       └── dns.py          # namecheap.domains.dns.* endpoints + builder
+│       ├── dns.py          # namecheap.domains.dns.* endpoints + builder
+│       ├── users.py        # namecheap.users.* endpoints
+│       └── whoisguard.py   # namecheap.whoisguard.* endpoints (domain privacy)
 ├── namecheap_cli/          # CLI (click)
 │   ├── __main__.py         # All commands in one file
 │   └── completion.py       # Shell completions

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: namecheap-python
-Version: 1.3.0
+Version: 1.5.0
 Summary: A friendly Python SDK for Namecheap API
 Project-URL: Homepage, https://github.com/adriangalilea/namecheap-python
 Project-URL: Repository, https://github.com/adriangalilea/namecheap-python
@@ -377,6 +377,18 @@ print(f"{bal.available_balance} {bal.currency}")  # '4932.96 USD'
 print(bal.funds_required_for_auto_renew)          # Decimal('20.16')
 ```
 
+### Pricing
+
+```python
+# Get registration pricing for a specific TLD
+pricing = nc.users.get_pricing("DOMAIN", action="REGISTER", product_name="com")
+for p in pricing["REGISTER"]["com"]:
+    print(f"{p.duration} year: ${p.your_price} (regular: ${p.regular_price})")
+
+# Get all domain pricing (large response — cache it)
+all_pricing = nc.users.get_pricing("DOMAIN")
+```
+
 ### Email Forwarding
 
 ```python
@@ -400,6 +412,41 @@ print(f"{contacts.registrant.first_name} {contacts.registrant.last_name}")
 print(contacts.registrant.email)
 ```
 
+### TLD List
+
+```python
+tlds = nc.domains.get_tld_list()
+print(f"{len(tlds)} TLDs supported")
+
+# Filter to API-registerable TLDs
+registerable = [t for t in tlds if t.is_api_registerable]
+for t in registerable[:5]:
+    print(f".{t.name} ({t.type}) — {t.min_register_years}-{t.max_register_years} years")
+```
+
+### Domain Privacy (WhoisGuard)
+
+```python
+# List all WhoisGuard subscriptions
+entries = nc.whoisguard.get_list()
+for e in entries:
+    print(f"{e.domain} (ID={e.id}) status={e.status}")
+
+# Enable privacy (resolves WhoisGuard ID from domain name automatically)
+nc.whoisguard.enable("example.com", "me@gmail.com")
+
+# Disable privacy
+nc.whoisguard.disable("example.com")
+
+# Renew privacy
+result = nc.whoisguard.renew("example.com", years=1)
+print(f"Charged: {result['charged_amount']}")
+
+# Rotate the masked forwarding email
+result = nc.whoisguard.change_email("example.com")
+print(f"New: {result['new_email']}")
+```
+
 ### Domain Management
 
 ```python
@@ -461,6 +508,15 @@ except NamecheapError as e:
 
 This section documents undocumented or unusual Namecheap API behaviors we've discovered:
 
+### No WHOIS lookups or Marketplace data
+
+The Namecheap API only operates on domains **in your account**. There is no API for:
+- WHOIS lookups on arbitrary domains
+- Checking if a domain is listed on [Namecheap Marketplace](https://www.namecheap.com/domains/marketplace/)
+- Aftermarket pricing or availability
+
+`domains.check()` tells you if a domain is **unregistered**, not if it's for sale by its owner.
+
 ### TTL "Automatic" = 1799 seconds
 
 The Namecheap web interface displays TTL as **"Automatic"** when the value is exactly **1799 seconds**, but shows **"30 min"** when it's **1800 seconds**. This behavior is completely undocumented in their official API documentation.
@@ -477,15 +533,15 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 
 | API | Status | Methods |
 |-----|--------|---------|
-| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `getTldList`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
 | `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding`, `setEmailForwarding` |
-| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
-| `namecheap.domains.*` | 🚧 Planned | `getTldList`, `reactivate` |
-| `namecheap.users.address.*` | 🚧 Planned | `create`, `delete`, `getInfo`, `getList`, `setDefault`, `update` |
-| `namecheap.ssl.*` | 🚧 Planned | `create`, `activate`, `renew`, `revoke`, `getList`, `getInfo`, `parseCSR`, `reissue`, and more |
-| `namecheap.domains.transfer.*` | 🚧 Planned | `create`, `getStatus`, `updateStatus`, `getList` |
-| `namecheap.domains.ns.*` | 🚧 Planned | Glue records — `create`, `delete`, `getInfo`, `update` |
-| `namecheap.domainprivacy.*` | 🚧 Planned | `enable`, `disable`, `renew`, `getList`, `changeemailaddress` |
+| `namecheap.whoisguard.*` | ✅ Done | `getList`, `enable`, `disable`, `renew`, `changeEmailAddress` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing`. Remaining methods are account management (`changePassword`, `update`, `create`, `login`, `resetPassword`) — only useful if building a reseller platform |
+| `namecheap.users.address.*` | 🚧 Planned | Saved address book for `domains.register()` — store contacts once, reuse by ID instead of passing full contact info every time |
+| `namecheap.ssl.*` | 🚧 Planned | Full SSL certificate lifecycle — purchase, activate with CSR, renew, revoke, reissue. Complex multi-step workflows with approval emails |
+| `namecheap.domains.transfer.*` | 🚧 Planned | Transfer domains into Namecheap programmatically — initiate, track status, retry |
+| `namecheap.domains.ns.*` | 🚧 Planned | Glue records — only needed if you run your own nameservers and need to register them with the registry |
+| `namecheap.domains.*` | 🚧 Planned | `reactivate` — restore expired domains within the redemption grace period |
 
 ## 🛠️ Development
 
@@ -497,7 +553,7 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 🤝 Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request. See the [Development Guide](docs/dev/README.md) for setup instructions and guidelines.
+Contributions are welcome! Please feel free to submit a Pull Request. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and guidelines.
 
 ### Contributors
 

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/README.md

@@ -335,6 +335,18 @@ print(f"{bal.available_balance} {bal.currency}")  # '4932.96 USD'
 print(bal.funds_required_for_auto_renew)          # Decimal('20.16')
 ```
 
+### Pricing
+
+```python
+# Get registration pricing for a specific TLD
+pricing = nc.users.get_pricing("DOMAIN", action="REGISTER", product_name="com")
+for p in pricing["REGISTER"]["com"]:
+    print(f"{p.duration} year: ${p.your_price} (regular: ${p.regular_price})")
+
+# Get all domain pricing (large response — cache it)
+all_pricing = nc.users.get_pricing("DOMAIN")
+```
+
 ### Email Forwarding
 
 ```python
@@ -358,6 +370,41 @@ print(f"{contacts.registrant.first_name} {contacts.registrant.last_name}")
 print(contacts.registrant.email)
 ```
 
+### TLD List
+
+```python
+tlds = nc.domains.get_tld_list()
+print(f"{len(tlds)} TLDs supported")
+
+# Filter to API-registerable TLDs
+registerable = [t for t in tlds if t.is_api_registerable]
+for t in registerable[:5]:
+    print(f".{t.name} ({t.type}) — {t.min_register_years}-{t.max_register_years} years")
+```
+
+### Domain Privacy (WhoisGuard)
+
+```python
+# List all WhoisGuard subscriptions
+entries = nc.whoisguard.get_list()
+for e in entries:
+    print(f"{e.domain} (ID={e.id}) status={e.status}")
+
+# Enable privacy (resolves WhoisGuard ID from domain name automatically)
+nc.whoisguard.enable("example.com", "me@gmail.com")
+
+# Disable privacy
+nc.whoisguard.disable("example.com")
+
+# Renew privacy
+result = nc.whoisguard.renew("example.com", years=1)
+print(f"Charged: {result['charged_amount']}")
+
+# Rotate the masked forwarding email
+result = nc.whoisguard.change_email("example.com")
+print(f"New: {result['new_email']}")
+```
+
 ### Domain Management
 
 ```python
@@ -419,6 +466,15 @@ except NamecheapError as e:
 
 This section documents undocumented or unusual Namecheap API behaviors we've discovered:
 
+### No WHOIS lookups or Marketplace data
+
+The Namecheap API only operates on domains **in your account**. There is no API for:
+- WHOIS lookups on arbitrary domains
+- Checking if a domain is listed on [Namecheap Marketplace](https://www.namecheap.com/domains/marketplace/)
+- Aftermarket pricing or availability
+
+`domains.check()` tells you if a domain is **unregistered**, not if it's for sale by its owner.
+
 ### TTL "Automatic" = 1799 seconds
 
 The Namecheap web interface displays TTL as **"Automatic"** when the value is exactly **1799 seconds**, but shows **"30 min"** when it's **1800 seconds**. This behavior is completely undocumented in their official API documentation.
@@ -435,15 +491,15 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 
 | API | Status | Methods |
 |-----|--------|---------|
-| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `getContacts`, `getTldList`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
 | `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding`, `setEmailForwarding` |
-| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
-| `namecheap.domains.*` | 🚧 Planned | `getTldList`, `reactivate` |
-| `namecheap.users.address.*` | 🚧 Planned | `create`, `delete`, `getInfo`, `getList`, `setDefault`, `update` |
-| `namecheap.ssl.*` | 🚧 Planned | `create`, `activate`, `renew`, `revoke`, `getList`, `getInfo`, `parseCSR`, `reissue`, and more |
-| `namecheap.domains.transfer.*` | 🚧 Planned | `create`, `getStatus`, `updateStatus`, `getList` |
-| `namecheap.domains.ns.*` | 🚧 Planned | Glue records — `create`, `delete`, `getInfo`, `update` |
-| `namecheap.domainprivacy.*` | 🚧 Planned | `enable`, `disable`, `renew`, `getList`, `changeemailaddress` |
+| `namecheap.whoisguard.*` | ✅ Done | `getList`, `enable`, `disable`, `renew`, `changeEmailAddress` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing`. Remaining methods are account management (`changePassword`, `update`, `create`, `login`, `resetPassword`) — only useful if building a reseller platform |
+| `namecheap.users.address.*` | 🚧 Planned | Saved address book for `domains.register()` — store contacts once, reuse by ID instead of passing full contact info every time |
+| `namecheap.ssl.*` | 🚧 Planned | Full SSL certificate lifecycle — purchase, activate with CSR, renew, revoke, reissue. Complex multi-step workflows with approval emails |
+| `namecheap.domains.transfer.*` | 🚧 Planned | Transfer domains into Namecheap programmatically — initiate, track status, retry |
+| `namecheap.domains.ns.*` | 🚧 Planned | Glue records — only needed if you run your own nameservers and need to register them with the registry |
+| `namecheap.domains.*` | 🚧 Planned | `reactivate` — restore expired domains within the redemption grace period |
 
 ## 🛠️ Development
 
@@ -455,7 +511,7 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 🤝 Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request. See the [Development Guide](docs/dev/README.md) for setup instructions and guidelines.
+Contributions are welcome! Please feel free to submit a Pull Request. See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and guidelines.
 
 ### Contributors
 

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "namecheap-python"
-version = "1.3.0"
+version = "1.5.0"
 description = "A friendly Python SDK for Namecheap API"
 authors = [{name = "Adrian Galilea Delgado", email = "adriangalilea@gmail.com"}]
 readme = "README.md"

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/src/namecheap/__init__.py

@@ -22,9 +22,12 @@ from .models import (
     DomainInfo,
     EmailForward,
     Nameservers,
+    ProductPrice,
+    Tld,
+    WhoisguardEntry,
 )
 
-__version__ = "1.3.0"
+__version__ = "1.5.0"
 __all__ = [
     "AccountBalance",
     "ConfigurationError",
@@ -38,5 +41,8 @@ __all__ = [
     "Namecheap",
     "NamecheapError",
     "Nameservers",
+    "ProductPrice",
+    "Tld",
     "ValidationError",
+    "WhoisguardEntry",
 ]

{namecheap_python-1.3.0 → namecheap_python-1.5.0}/src/namecheap/_api/domains.py

@@ -9,7 +9,14 @@ from typing import Any
 import tldextract
 
 from namecheap.logging import logger
-from namecheap.models import Contact, Domain, DomainCheck, DomainContacts, DomainInfo
+from namecheap.models import (
+    Contact,
+    Domain,
+    DomainCheck,
+    DomainContacts,
+    DomainInfo,
+    Tld,
+)
 
 from .base import BaseAPI
 
@@ -202,6 +209,34 @@ class DomainsAPI(BaseAPI):
             aux_billing=parse_contact(result.get("AuxBilling", {})),
         )
 
+    def get_tld_list(self) -> builtins.list[Tld]:
+        """
+        Get list of all TLDs supported by Namecheap.
+
+        NOTE: Cache this response — it rarely changes and the API docs recommend it.
+
+        Returns:
+            List of Tld objects with registration/renewal constraints and capabilities
+
+        Examples:
+            >>> tlds = nc.domains.get_tld_list()
+            >>> registerable = [t for t in tlds if t.is_api_registerable]
+            >>> print(f"{len(registerable)} TLDs available for API registration")
+        """
+        result: Any = self._request(
+            "namecheap.domains.getTldList",
+            path="Tlds",
+        )
+
+        assert result, "API returned empty result for getTldList"
+
+        tlds = result.get("Tld", [])
+        if isinstance(tlds, dict):
+            tlds = [tlds]
+        assert isinstance(tlds, list), f"Unexpected Tld type: {type(tlds)}"
+
+        return [Tld.model_validate(t) for t in tlds]
+
     def register(
         self,
         domain: str,
@@ -383,153 +418,35 @@ class DomainsAPI(BaseAPI):
     def _get_pricing(
         self, domains: builtins.list[str]
     ) -> dict[str, dict[str, Decimal | None]]:
-        """
-        Get pricing information for domains.
+        """Get 1-year registration pricing for a list of domains.
 
-        Args:
-            domains: List of domain names
-
-        Returns:
-            Dict mapping domain to pricing info
+        Groups by TLD, fetches pricing via users.get_pricing(), and maps
+        back to individual domain names.
         """
-        pricing = {}
-        logger.debug(f"Getting pricing for domains: {domains}")
+        pricing: dict[str, dict[str, Decimal | None]] = {}
 
-        # Group domains by TLD for efficient API calls
+        # Group domains by TLD
         tld_groups: dict[str, builtins.list[str]] = {}
         for domain in domains:
-            ext = tldextract.extract(domain)
-            tld = ext.suffix
+            tld = tldextract.extract(domain).suffix
             if tld not in tld_groups:
                 tld_groups[tld] = []
             tld_groups[tld].append(domain)
 
-        logger.debug(f"TLD groups: {tld_groups}")
-
-        # Fetch pricing for each TLD group
         for tld, domain_list in tld_groups.items():
-            try:
-                logger.debug(f"Fetching pricing for TLD: {tld}")
-                # Get pricing for this TLD
-                result: Any = self._request(
-                    "namecheap.users.getPricing",
-                    {
-                        "ProductType": "DOMAIN",
-                        "ActionName": "REGISTER",
-                        "ProductName": tld,
-                    },
-                    path="UserGetPricingResult.ProductType",
-                )
-                assert isinstance(result, dict)
-                logger.debug(f"Pricing API response for {tld}: {result}")
-                logger.debug(f"Response type: {type(result)}")
-                logger.debug(
-                    f"Response keys: "
-                    f"{list(result.keys()) if isinstance(result, dict) else 'Not a dict'}"
-                )
-
-                # Extract pricing info
-                if isinstance(result, dict):
-                    logger.debug(f"Parsing pricing response for {tld}")
-
-                    # Get ProductCategory (could be a list or single dict)
-                    categories = result.get("ProductCategory", {})
-                    if not isinstance(categories, list):
-                        categories = [categories] if categories else []
-
-                    logger.debug(f"Found {len(categories)} categories")
-
-                    # Look for REGISTER category
-                    for category in categories:
-                        if not isinstance(category, dict):
-                            continue
-
-                        # Use normalized name for consistent access
-                        category_name = category.get("@Name", "")
-                        category_name_normalized = category.get(
-                            "@Name_normalized", category_name.lower()
-                        )
-                        logger.debug(
-                            f"Checking category: {category_name} "
-                            f"(normalized: {category_name_normalized})"
-                        )
-
-                        if category_name_normalized == "register":
-                            # Get products in this category
-                            products = category.get("Product", {})
-                            if not isinstance(products, list):
-                                products = [products] if products else []
-
-                            logger.debug(
-                                f"Found {len(products)} products in REGISTER category"
-                            )
-
-                            # Find the product matching our TLD
-                            for product in products:
-                                if not isinstance(product, dict):
-                                    continue
-
-                                product_name = product.get("@Name", "")
-                                logger.debug(
-                                    f"Checking product: {product_name} vs {tld}"
-                                )
-
-                                if product_name.lower() == tld.lower():
-                                    # Get price list
-                                    price_info = product.get("Price", [])
-                                    if not isinstance(price_info, list):
-                                        price_info = [price_info] if price_info else []
-
-                                    logger.debug(
-                                        f"Found {len(price_info)} price entries for {tld}"
-                                    )
-
-                                    # Find 1 year price
-                                    for price in price_info:
-                                        if not isinstance(price, dict):
-                                            continue
-
-                                        duration = price.get("@Duration", "")
-                                        if duration == "1":
-                                            regular_price = price.get("@RegularPrice")
-                                            your_price = price.get("@YourPrice")
-                                            retail_price = price.get("@RetailPrice")
-
-                                            # Get additional cost
-                                            # (normalization handles their typo)
-                                            price.get("@YourAdditionalCost", "0")
-
-                                            logger.debug(
-                                                f"Found prices for {tld}: "
-                                                f"regular={regular_price}, "
-                                                f"your={your_price}, "
-                                                f"retail={retail_price}"
-                                            )
-
-                                            # Apply to all domains with this TLD
-                                            for domain in domain_list:
-                                                pricing[domain] = {
-                                                    "regular_price": Decimal(
-                                                        regular_price
-                                                    )
-                                                    if regular_price
-                                                    else None,
-                                                    "your_price": Decimal(your_price)
-                                                    if your_price
-                                                    else None,
-                                                    "retail_price": Decimal(
-                                                        retail_price
-                                                    )
-                                                    if retail_price
-                                                    else None,
-                                                }
-                                            break
-                                    break
-                            break
-
-            except Exception as e:
-                # If pricing fails, continue without it
-                logger.error(f"Failed to get pricing for TLD {tld}: {e}")
-                logger.debug("Full error:", exc_info=True)
+            result = self.client.users.get_pricing(
+                "DOMAIN", action="REGISTER", product_name=tld
+            )
+            prices = result.get("REGISTER", {}).get(tld, [])
+
+            for p in prices:
+                if p.duration == 1:
+                    for domain in domain_list:
+                        pricing[domain] = {
+                            "regular_price": p.regular_price,
+                            "your_price": p.your_price,
+                            "retail_price": None,
+                        }
+                    break
 
         return pricing

namecheap_python-1.5.0/src/namecheap/_api/users.py

@@ -0,0 +1,102 @@
+"""Users API."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from namecheap.models import AccountBalance, ProductPrice
+
+from .base import BaseAPI
+
+
+class UsersAPI(BaseAPI):
+    """User account operations."""
+
+    def get_balances(self) -> AccountBalance:
+        """
+        Get account balance information.
+
+        Returns:
+            AccountBalance with available balance, earned amount, etc.
+
+        Examples:
+            >>> bal = nc.users.get_balances()
+            >>> print(f"{bal.available_balance} {bal.currency}")
+        """
+        result: Any = self._request(
+            "namecheap.users.getBalances",
+            path="UserGetBalancesResult",
+        )
+
+        assert result, "API returned empty result for getBalances"
+        return AccountBalance.model_validate(result)
+
+    def get_pricing(
+        self,
+        product_type: Literal["DOMAIN", "SSLCERTIFICATE"] = "DOMAIN",
+        *,
+        action: str | None = None,
+        product_name: str | None = None,
+    ) -> dict[str, dict[str, list[ProductPrice]]]:
+        """
+        Get pricing for products.
+
+        Returns a nested dict: {action: {product: [prices]}}.
+        For example: {"REGISTER": {"com": [ProductPrice(duration=1, ...), ...]}}
+
+        NOTE: Cache this response — Namecheap recommends it.
+
+        Args:
+            product_type: "DOMAIN" or "SSLCERTIFICATE"
+            action: Filter by action (REGISTER, RENEW, TRANSFER, REACTIVATE)
+            product_name: Filter by product/TLD name (e.g., "com")
+
+        Returns:
+            Nested dict of action -> product -> list of ProductPrice
+
+        Examples:
+            >>> pricing = nc.users.get_pricing("DOMAIN", action="REGISTER", product_name="com")
+            >>> prices = pricing["REGISTER"]["com"]
+            >>> print(f"1-year .com: ${prices[0].your_price}")
+        """
+        params: dict[str, Any] = {"ProductType": product_type}
+        if action:
+            params["ActionName"] = action
+        if product_name:
+            params["ProductName"] = product_name
+
+        result: Any = self._request(
+            "namecheap.users.getPricing",
+            params,
+            path="UserGetPricingResult.ProductType",
+        )
+
+        assert result, "API returned empty result for getPricing"
+
+        pricing: dict[str, dict[str, list[ProductPrice]]] = {}
+
+        categories = result.get("ProductCategory", [])
+        if isinstance(categories, dict):
+            categories = [categories]
+
+        for category in categories:
+            action_name = category.get("@Name", "").upper()
+
+            products = category.get("Product", [])
+            if isinstance(products, dict):
+                products = [products]
+
+            for product in products:
+                name = product.get("@Name", "").lower()
+
+                prices = product.get("Price", [])
+                if isinstance(prices, dict):
+                    prices = [prices]
+
+                parsed = [ProductPrice.model_validate(p) for p in prices]
+
+                if action_name not in pricing:
+                    pricing[action_name] = {}
+                pricing[action_name][name] = parsed
+
+        return pricing