namecheap-python 1.1.0__tar.gz → 1.2.0__tar.gz

namecheap_python-1.2.0/CLAUDE.md

@@ -0,0 +1,2 @@
+@README.md
+@CONTRIBUTING.md

namecheap_python-1.2.0/CONTRIBUTING.md

@@ -0,0 +1,113 @@
+# Contributing
+
+## Setup
+
+```bash
+git clone https://github.com/adriangalilea/namecheap-python.git
+cd namecheap-python
+uv sync --all-extras
+pre-commit install
+```
+
+## Code Quality
+
+```bash
+uv run ruff check        # lint
+uv run ruff check --fix  # auto-fix
+uv run ruff format       # format
+
+pre-commit run --all-files  # run all hooks
+```
+
+## Building
+
+```bash
+uv build
+```
+
+## Release
+
+Automated via GitHub Actions on push to `main`. If the version in `pyproject.toml` doesn't exist on PyPI, CI publishes automatically, creates a git tag, and generates a GitHub release with changelog via [git-cliff](https://git-cliff.org/).
+
+Bump version in both `pyproject.toml` and `src/namecheap/__init__.py`.
+
+## Debugging
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+Or set `NAMECHEAP_DEBUG=true`.
+
+## Architecture
+
+### Project Structure
+
+```
+src/
+├── namecheap/              # Core SDK
+│   ├── client.py           # Main client — wires up API classes
+│   ├── models.py           # Pydantic models (all API data types live here)
+│   ├── errors.py           # Exceptions with helpful messages
+│   ├── logging.py          # Colored logging and error display
+│   └── _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
+├── namecheap_cli/          # CLI (click)
+│   ├── __main__.py         # All commands in one file
+│   └── completion.py       # Shell completions
+└── namecheap_dns_tui/      # TUI (textual)
+    └── __main__.py
+```
+
+### Key Patterns
+
+**SDK layer** (`src/namecheap/_api/`):
+- Every API class extends `BaseAPI` which provides `_request(command, params, model=, path=)`
+- `_request` handles auth params, XML parsing, error handling, and Pydantic deserialization
+- Pass `model=SomeModel` to auto-parse, or omit for raw dict access
+- Pass `path="DotSeparated.Path"` to navigate the XML response
+- Domain parsing uses `tldextract` to split into SLD/TLD — see any method in `dns.py`
+- Return Pydantic models, not dicts — see `Nameservers`, `DNSRecord`, `Domain`, etc.
+- Use `assert` for assumptions, `ValueError` for bad user input
+
+**Models** (`src/namecheap/models.py`):
+- `XMLModel` base handles XML attribute aliases (`@Name` → `name`) and boolean parsing
+- All new data types go here and get exported from `__init__.py`
+
+**CLI layer** (`src/namecheap_cli/__main__.py`):
+- Commands use `@pass_config` decorator for client initialization
+- Interactive operations use `rich.progress.Progress` with `SpinnerColumn` for loading
+- Destructive operations use `rich.prompt.Confirm.ask` with `--yes/-y` to skip
+- Table output via `rich.table.Table`, with `output_formatter()` for JSON/YAML alternatives
+- Error handling: catch `NamecheapError`, print with `[red]`, `sys.exit(1)`
+
+**DNS Builder** (`src/namecheap/_api/dns.py`):
+- Fluent interface: `builder.a(...).mx(...).txt(...)` returns `Self` for chaining
+- Default TTL is 1799 (displays as "Automatic" in Namecheap UI)
+
+### Adding a New API Endpoint
+
+1. Add Pydantic model in `models.py`, export from `__init__.py`
+2. Add method in the appropriate `_api/*.py` file using `self._request()`
+3. Add CLI command in `__main__.py` following existing patterns
+4. Update the API Coverage table in `README.md`
+
+Best reference: `dns.py:get_nameservers()` for SDK, `__main__.py:dns_nameservers()` for CLI.
+
+## PR Checklist
+
+- [ ] `uv run ruff check` passes
+- [ ] `uv run ruff format --check` passes
+- [ ] Examples work correctly
+- [ ] Documentation updated if needed
+
+## Links
+
+- [Namecheap API Documentation](https://www.namecheap.com/support/api/methods/)
+- [Pydantic Documentation](https://docs.pydantic.dev/)
+- [Click Documentation](https://click.palletsprojects.com/)
+- [Textual Documentation](https://textual.textualize.io/)
+- [Ruff Documentation](https://docs.astral.sh/ruff/)

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: namecheap-python
-Version: 1.1.0
+Version: 1.2.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
@@ -42,6 +42,12 @@ Description-Content-Type: text/markdown
 
 # Namecheap Python SDK
 
+[![PyPI version](https://badge.fury.io/py/namecheap-python.svg)](https://pypi.org/project/namecheap-python/)
+[![Downloads](https://pepy.tech/badge/namecheap-python)](https://pepy.tech/project/namecheap-python)
+[![Downloads/month](https://pepy.tech/badge/namecheap-python/month)](https://pepy.tech/project/namecheap-python)
+[![Python](https://img.shields.io/pypi/pyversions/namecheap-python)](https://pypi.org/project/namecheap-python/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A modern, friendly Python SDK for the Namecheap API with comprehensive CLI and TUI tools.
 
 ## 🚀 Features
@@ -206,6 +212,38 @@ Adding CNAME record to tdo.garden...
 ```
 
 
+Check account balance:
+
+```bash
+❯ namecheap-cli account balance
+          Account Balance
+┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┓
+┃ Field               ┃    Amount ┃
+┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━┩
+│ Available Balance   │  0.00 USD │
+│ Account Balance     │  0.00 USD │
+│ Earned Amount       │  0.00 USD │
+│ Withdrawable        │  0.00 USD │
+│ Auto-Renew Required │ 20.16 USD │
+└─────────────────────┴───────────┘
+```
+
+Get detailed domain info:
+
+```bash
+❯ namecheap-cli domain info self.fm
+
+Domain Information: self.fm
+
+Status: Ok
+Owner: adriangalilea
+Created: 07/15/2023
+Expires: 07/15/2026
+Premium: No
+WHOIS Guard: ✓ Enabled
+DNS Provider: CUSTOM
+```
+
 You can also export DNS records:
 
 ```bash
@@ -320,6 +358,33 @@ nc.dns.set_custom_nameservers("example.com", [
 nc.dns.set_default_nameservers("example.com")
 ```
 
+### Domain Info
+
+```python
+info = nc.domains.get_info("example.com")
+print(info.status)              # 'Ok'
+print(info.whoisguard_enabled)  # True
+print(info.dns_provider)        # 'CUSTOM'
+print(info.created)             # '07/15/2023'
+print(info.expires)             # '07/15/2026'
+```
+
+### Account Balance
+
+```python
+bal = nc.users.get_balances()
+print(f"{bal.available_balance} {bal.currency}")  # '4932.96 USD'
+print(bal.funds_required_for_auto_renew)          # Decimal('20.16')
+```
+
+### Email Forwarding
+
+```python
+rules = nc.dns.get_email_forwarding("example.com")
+for r in rules:
+    print(f"{r.mailbox} -> {r.forward_to}")
+```
+
 ### Domain Management
 
 ```python
@@ -393,22 +458,24 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1799)  # Shows as "Automatic"
 nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 ```
 
-## 🚧 Pending Features
-
-The following Namecheap API features are planned for future releases:
-
-- **SSL API** - Certificate management
-- **Domain Transfer API** - Transfer domains between registrars
-- **Domain NS API** - Glue record management (child nameservers)
-- **Users API** - Account management and balance checking
-- **Whois API** - WHOIS information lookups
-- **Email Forwarding** - Email forwarding configuration
-
-See [pending.md](pending.md) for full details.
+## 📊 [API Coverage](https://www.namecheap.com/support/api/methods/)
+
+| API | Status | Methods |
+|-----|--------|---------|
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
+| `namecheap.domains.*` | 🚧 Planned | `getContacts`, `getTldList`, `reactivate` |
+| `namecheap.domains.dns.*` | 🚧 Planned | `setEmailForwarding` |
+| `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` |
 
 ## 🛠️ Development
 
-See [Development Guide](docs/dev/README.md) for detailed development instructions.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup and development guidelines.
 
 ## 📝 License
 
@@ -420,4 +487,6 @@ Contributions are welcome! Please feel free to submit a Pull Request. See the [D
 
 ### Contributors
 
+- [@huntertur](https://github.com/huntertur) — Rich dependency fix
+- [@jeffmcadams](https://github.com/jeffmcadams) — Domain serialization round-trip
 - [@cosmin](https://github.com/cosmin) — Nameserver management

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/README.md

@@ -1,5 +1,11 @@
 # Namecheap Python SDK
 
+[![PyPI version](https://badge.fury.io/py/namecheap-python.svg)](https://pypi.org/project/namecheap-python/)
+[![Downloads](https://pepy.tech/badge/namecheap-python)](https://pepy.tech/project/namecheap-python)
+[![Downloads/month](https://pepy.tech/badge/namecheap-python/month)](https://pepy.tech/project/namecheap-python)
+[![Python](https://img.shields.io/pypi/pyversions/namecheap-python)](https://pypi.org/project/namecheap-python/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A modern, friendly Python SDK for the Namecheap API with comprehensive CLI and TUI tools.
 
 ## 🚀 Features
@@ -164,6 +170,38 @@ Adding CNAME record to tdo.garden...
 ```
 
 
+Check account balance:
+
+```bash
+❯ namecheap-cli account balance
+          Account Balance
+┏━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┓
+┃ Field               ┃    Amount ┃
+┡━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━┩
+│ Available Balance   │  0.00 USD │
+│ Account Balance     │  0.00 USD │
+│ Earned Amount       │  0.00 USD │
+│ Withdrawable        │  0.00 USD │
+│ Auto-Renew Required │ 20.16 USD │
+└─────────────────────┴───────────┘
+```
+
+Get detailed domain info:
+
+```bash
+❯ namecheap-cli domain info self.fm
+
+Domain Information: self.fm
+
+Status: Ok
+Owner: adriangalilea
+Created: 07/15/2023
+Expires: 07/15/2026
+Premium: No
+WHOIS Guard: ✓ Enabled
+DNS Provider: CUSTOM
+```
+
 You can also export DNS records:
 
 ```bash
@@ -278,6 +316,33 @@ nc.dns.set_custom_nameservers("example.com", [
 nc.dns.set_default_nameservers("example.com")
 ```
 
+### Domain Info
+
+```python
+info = nc.domains.get_info("example.com")
+print(info.status)              # 'Ok'
+print(info.whoisguard_enabled)  # True
+print(info.dns_provider)        # 'CUSTOM'
+print(info.created)             # '07/15/2023'
+print(info.expires)             # '07/15/2026'
+```
+
+### Account Balance
+
+```python
+bal = nc.users.get_balances()
+print(f"{bal.available_balance} {bal.currency}")  # '4932.96 USD'
+print(bal.funds_required_for_auto_renew)          # Decimal('20.16')
+```
+
+### Email Forwarding
+
+```python
+rules = nc.dns.get_email_forwarding("example.com")
+for r in rules:
+    print(f"{r.mailbox} -> {r.forward_to}")
+```
+
 ### Domain Management
 
 ```python
@@ -351,22 +416,24 @@ nc.dns.builder().a("www", "192.0.2.1", ttl=1799)  # Shows as "Automatic"
 nc.dns.builder().a("www", "192.0.2.1", ttl=1800)  # Shows as "30 min"
 ```
 
-## 🚧 Pending Features
-
-The following Namecheap API features are planned for future releases:
-
-- **SSL API** - Certificate management
-- **Domain Transfer API** - Transfer domains between registrars
-- **Domain NS API** - Glue record management (child nameservers)
-- **Users API** - Account management and balance checking
-- **Whois API** - WHOIS information lookups
-- **Email Forwarding** - Email forwarding configuration
-
-See [pending.md](pending.md) for full details.
+## 📊 [API Coverage](https://www.namecheap.com/support/api/methods/)
+
+| API | Status | Methods |
+|-----|--------|---------|
+| `namecheap.domains.*` | ✅ Done | `check`, `list`, `getInfo`, `register`, `renew`, `setContacts`, `lock`/`unlock` |
+| `namecheap.domains.dns.*` | ✅ Done | `getHosts`, `setHosts` (builder pattern), `add`, `delete`, `export`, `getList`, `setCustom`, `setDefault`, `getEmailForwarding` |
+| `namecheap.users.*` | ⚠️ Partial | `getBalances`, `getPricing` (needs debugging). Planned: `changePassword`, `update`, `create`, `login`, `resetPassword` |
+| `namecheap.domains.*` | 🚧 Planned | `getContacts`, `getTldList`, `reactivate` |
+| `namecheap.domains.dns.*` | 🚧 Planned | `setEmailForwarding` |
+| `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` |
 
 ## 🛠️ Development
 
-See [Development Guide](docs/dev/README.md) for detailed development instructions.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup and development guidelines.
 
 ## 📝 License
 
@@ -378,4 +445,6 @@ Contributions are welcome! Please feel free to submit a Pull Request. See the [D
 
 ### Contributors
 
+- [@huntertur](https://github.com/huntertur) — Rich dependency fix
+- [@jeffmcadams](https://github.com/jeffmcadams) — Domain serialization round-trip
 - [@cosmin](https://github.com/cosmin) — Nameserver management

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/pyproject.toml

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

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap/__init__.py

@@ -12,15 +12,27 @@ from __future__ import annotations
 
 from .client import Namecheap
 from .errors import ConfigurationError, NamecheapError, ValidationError
-from .models import Contact, DNSRecord, Domain, DomainCheck, Nameservers
+from .models import (
+    AccountBalance,
+    Contact,
+    DNSRecord,
+    Domain,
+    DomainCheck,
+    DomainInfo,
+    EmailForward,
+    Nameservers,
+)
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __all__ = [
+    "AccountBalance",
     "ConfigurationError",
     "Contact",
     "DNSRecord",
     "Domain",
     "DomainCheck",
+    "DomainInfo",
+    "EmailForward",
     "Namecheap",
     "NamecheapError",
     "Nameservers",

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap/_api/dns.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 import tldextract
 
-from namecheap.models import DNSRecord, Nameservers
+from namecheap.models import DNSRecord, EmailForward, Nameservers
 
 from .base import BaseAPI
 
@@ -494,3 +494,37 @@ class DnsAPI(BaseAPI):
         nameservers = [ns_data] if isinstance(ns_data, str) else ns_data
 
         return Nameservers(is_default=is_default, nameservers=nameservers)
+
+    def get_email_forwarding(self, domain: str) -> list[EmailForward]:
+        """
+        Get email forwarding rules for a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            List of EmailForward rules
+
+        Examples:
+            >>> rules = nc.dns.get_email_forwarding("example.com")
+            >>> for r in rules:
+            ...     print(f"{r.mailbox} -> {r.forward_to}")
+        """
+        result: Any = self._request(
+            "namecheap.domains.dns.getEmailForwarding",
+            {"DomainName": domain},
+            path="DomainDNSGetEmailForwardingResult",
+        )
+
+        if not result:
+            return []
+
+        forwards = result.get("Forward", [])
+        if isinstance(forwards, dict):
+            forwards = [forwards]
+        assert isinstance(forwards, list), f"Unexpected Forward type: {type(forwards)}"
+
+        return [
+            EmailForward(mailbox=f.get("@mailbox", ""), forward_to=f.get("#text", ""))
+            for f in forwards
+        ]

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap/_api/domains.py

@@ -9,7 +9,7 @@ from typing import Any
 import tldextract
 
 from namecheap.logging import logger
-from namecheap.models import Contact, Domain, DomainCheck
+from namecheap.models import Contact, Domain, DomainCheck, DomainInfo
 
 from .base import BaseAPI
 
@@ -110,6 +110,52 @@ class DomainsAPI(BaseAPI):
             return [results]
         return results if isinstance(results, list) else []
 
+    def get_info(self, domain: str) -> DomainInfo:
+        """
+        Get detailed information about a domain.
+
+        Args:
+            domain: Domain name
+
+        Returns:
+            DomainInfo with status, whoisguard, DNS provider, etc.
+
+        Examples:
+            >>> info = nc.domains.get_info("example.com")
+            >>> print(f"{info.domain} status={info.status} whoisguard={info.whoisguard_enabled}")
+        """
+        result: Any = self._request(
+            "namecheap.domains.getInfo",
+            {"DomainName": domain},
+            path="DomainGetInfoResult",
+        )
+
+        assert result, f"API returned empty result for {domain} getInfo"
+
+        # Extract nested fields into flat structure
+        domain_details = result.get("DomainDetails", {})
+        whoisguard = result.get("Whoisguard", {})
+        dns_details = result.get("DnsDetails", {})
+
+        flat = {
+            "@ID": result.get("@ID"),
+            "@DomainName": result.get("@DomainName"),
+            "@OwnerName": result.get("@OwnerName"),
+            "@IsOwner": result.get("@IsOwner"),
+            "@IsPremium": result.get("@IsPremium", "false"),
+            "@Status": result.get("@Status"),
+            "created": domain_details.get("CreatedDate"),
+            "expires": domain_details.get("ExpiredDate"),
+            "whoisguard_enabled": whoisguard.get("@Enabled", "false").lower() == "true"
+            if isinstance(whoisguard, dict)
+            else False,
+            "dns_provider": dns_details.get("@ProviderType")
+            if isinstance(dns_details, dict)
+            else None,
+        }
+
+        return DomainInfo.model_validate(flat)
+
     def register(
         self,
         domain: str,

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

@@ -0,0 +1,32 @@
+"""Users API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from namecheap.models import AccountBalance
+
+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)

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap/client.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING:
 
     from ._api.dns import DnsAPI
     from ._api.domains import DomainsAPI
+    from ._api.users import UsersAPI
 
 
 class Namecheap:
@@ -110,6 +111,13 @@ class Namecheap:
 
         return DnsAPI(self)
 
+    @cached_property
+    def users(self) -> UsersAPI:
+        """User account operations."""
+        from ._api.users import UsersAPI
+
+        return UsersAPI(self)
+
     def __enter__(self) -> Self:
         """Enter context manager."""
         return self

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap/models.py

@@ -251,6 +251,66 @@ class Domain(XMLModel):
         raise ValueError(f"Cannot parse datetime from {v}")
 
 
+class AccountBalance(BaseModel):
+    """Account balance information."""
+
+    currency: str = Field(alias="@Currency")
+    available_balance: Decimal = Field(alias="@AvailableBalance")
+    account_balance: Decimal = Field(alias="@AccountBalance")
+    earned_amount: Decimal = Field(alias="@EarnedAmount")
+    withdrawable_amount: Decimal = Field(alias="@WithdrawableAmount")
+    funds_required_for_auto_renew: Decimal = Field(alias="@FundsRequiredForAutoRenew")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator(
+        "available_balance",
+        "account_balance",
+        "earned_amount",
+        "withdrawable_amount",
+        "funds_required_for_auto_renew",
+        mode="before",
+    )
+    @classmethod
+    def parse_decimal(cls, v: Any) -> Decimal:
+        return Decimal(str(v)) if v is not None else Decimal("0")
+
+
+class DomainInfo(BaseModel):
+    """Detailed domain information from getInfo."""
+
+    id: int = Field(alias="@ID")
+    domain: str = Field(alias="@DomainName")
+    owner: str = Field(alias="@OwnerName")
+    is_owner: bool = Field(alias="@IsOwner")
+    is_premium: bool = Field(alias="@IsPremium", default=False)
+    status: str = Field(alias="@Status")
+    created: str | None = Field(default=None)
+    expires: str | None = Field(default=None)
+    whoisguard_enabled: bool = Field(default=False)
+    dns_provider: str | None = Field(default=None)
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator("is_owner", "is_premium", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() == "true"
+        return False
+
+
+class EmailForward(BaseModel):
+    """Email forwarding rule."""
+
+    mailbox: str = Field(alias="@mailbox")
+    forward_to: str
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
 class Nameservers(BaseModel):
     """Current nameserver configuration for a domain."""
 

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/src/namecheap_cli/__main__.py

@@ -367,57 +367,31 @@ def domain_info(config: Config, domain: str) -> None:
     nc = config.init_client()
 
     try:
-        domains = nc.domains.list()
-        domain_obj = next((d for d in domains if d.name == domain), None)
-
-        if not domain_obj:
-            console.print(f"[red]❌ Domain {domain} not found in your account[/red]")
-            sys.exit(1)
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Getting info for {domain}...", total=None)
+            info = nc.domains.get_info(domain)
 
         if config.output_format == "table":
             console.print(f"\n[bold cyan]Domain Information: {domain}[/bold cyan]\n")
-            console.print(
-                f"[bold]Status:[/bold] "
-                f"{'Active' if not domain_obj.is_expired else '[red]Expired[/red]'}"
-            )
-            console.print(
-                f"[bold]Created:[/bold] {domain_obj.created.strftime('%Y-%m-%d')}"
-            )
-            console.print(
-                f"[bold]Expires:[/bold] {domain_obj.expires.strftime('%Y-%m-%d')}"
-            )
-            console.print(
-                f"[bold]Auto-Renew:[/bold] {'✓ Enabled' if domain_obj.auto_renew else '✗ Disabled'}"
-            )
-            console.print(
-                f"[bold]Locked:[/bold] {'🔒 Yes' if domain_obj.is_locked else '🔓 No'}"
-            )
+            console.print(f"[bold]Status:[/bold] {info.status}")
+            console.print(f"[bold]Owner:[/bold] {info.owner}")
+            if info.created:
+                console.print(f"[bold]Created:[/bold] {info.created}")
+            if info.expires:
+                console.print(f"[bold]Expires:[/bold] {info.expires}")
+            console.print(f"[bold]Premium:[/bold] {'Yes' if info.is_premium else 'No'}")
             console.print(
                 f"[bold]WHOIS Guard:[/bold] "
-                f"{'✓ Enabled' if domain_obj.whois_guard else '✗ Disabled'}"
+                f"{'✓ Enabled' if info.whoisguard_enabled else '✗ Disabled'}"
             )
-
-            # Calculate days until expiration
-            days_left = (domain_obj.expires - datetime.now()).days
-            if days_left < 30:
-                console.print(
-                    f"\n⚠️  [yellow]Domain expires in {days_left} days![/yellow]"
-                )
-            elif days_left < 60:
-                console.print(f"\n📅 Domain expires in {days_left} days")
-
+            if info.dns_provider:
+                console.print(f"[bold]DNS Provider:[/bold] {info.dns_provider}")
         else:
-            data = {
-                "domain": domain_obj.name,
-                "status": "active" if not domain_obj.is_expired else "expired",
-                "created": domain_obj.created.isoformat(),
-                "expires": domain_obj.expires.isoformat(),
-                "auto_renew": domain_obj.auto_renew,
-                "locked": domain_obj.is_locked,
-                "whois_guard": domain_obj.whois_guard,
-                "days_until_expiration": (domain_obj.expires - datetime.now()).days,
-            }
-            output_formatter(data, config.output_format)
+            output_formatter(info.model_dump(), config.output_format)
 
     except NamecheapError as e:
         console.print(f"[red]❌ Error: {e}[/red]")
@@ -906,6 +880,45 @@ def dns_export(config: Config, domain: str, format: str, output) -> None:
         sys.exit(1)
 
 
+@dns_group.command("email-forwarding")
+@click.argument("domain")
+@pass_config
+def dns_email_forwarding(config: Config, domain: str) -> None:
+    """Show email forwarding rules for a domain."""
+    nc = config.init_client()
+
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task(f"Getting email forwarding for {domain}...", total=None)
+            rules = nc.dns.get_email_forwarding(domain)
+
+        if config.output_format == "table":
+            if not rules:
+                console.print(
+                    f"\n[yellow]No email forwarding rules for {domain}[/yellow]"
+                )
+                return
+
+            table = Table(title=f"Email Forwarding for {domain}")
+            table.add_column("Mailbox", style="cyan")
+            table.add_column("Forwards To", style="green")
+
+            for rule in rules:
+                table.add_row(f"{rule.mailbox}@{domain}", rule.forward_to)
+
+            console.print(table)
+        else:
+            output_formatter([r.model_dump() for r in rules], config.output_format)
+
+    except NamecheapError as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        sys.exit(1)
+
+
 @cli.group("account")
 def account_group() -> None:
     """Account management commands."""
@@ -916,14 +929,37 @@ def account_group() -> None:
 @pass_config
 def account_balance(config: Config) -> None:
     """Check account balance."""
-    config.init_client()
+    nc = config.init_client()
 
     try:
-        # This would need to be implemented in the SDK
-        console.print(
-            "[yellow]Account balance check not yet implemented in SDK[/yellow]"
-        )
-        console.print("This feature requires the users.getBalances API method")
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True,
+        ) as progress:
+            progress.add_task("Getting account balance...", total=None)
+            bal = nc.users.get_balances()
+
+        if config.output_format == "table":
+            table = Table(title="Account Balance")
+            table.add_column("Field", style="cyan")
+            table.add_column("Amount", style="green", justify="right")
+
+            table.add_row(
+                "Available Balance", f"{bal.available_balance} {bal.currency}"
+            )
+            table.add_row("Account Balance", f"{bal.account_balance} {bal.currency}")
+            table.add_row("Earned Amount", f"{bal.earned_amount} {bal.currency}")
+            table.add_row("Withdrawable", f"{bal.withdrawable_amount} {bal.currency}")
+            if bal.funds_required_for_auto_renew > 0:
+                table.add_row(
+                    "Auto-Renew Required",
+                    f"{bal.funds_required_for_auto_renew} {bal.currency}",
+                )
+
+            console.print(table)
+        else:
+            output_formatter(bal.model_dump(mode="json"), config.output_format)
 
     except NamecheapError as e:
         console.print(f"[red]❌ Error: {e}[/red]")

{namecheap_python-1.1.0 → namecheap_python-1.2.0}/uv.lock

@@ -200,7 +200,7 @@ wheels = [
 
 [[package]]
 name = "namecheap-python"
-version = "1.1.0"
+version = "1.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

namecheap_python-1.1.0/docs/dev/README.md

@@ -1,220 +0,0 @@
-# Development Guide
-
-## 🛠️ Development Setup
-
-### Prerequisites
-
-- Python 3.12+
-- [uv](https://docs.astral.sh/uv/) package manager
-- Git
-
-### Setup Development Environment
-
-```bash
-# Clone repository
-git clone https://github.com/adriangalilea/namecheap-python.git
-cd namecheap-python
-
-# Install with uv (includes all extras and dev dependencies)
-uv sync --all-extras
-
-# Install pre-commit hooks
-pre-commit install
-```
-
-## 🧪 Running Tests
-
-```bash
-# Run all tests
-uv run pytest
-
-# Run with coverage
-uv run pytest --cov=namecheap --cov-report=term-missing
-
-# Run specific test file
-uv run pytest tests/test_domains.py
-
-# Run with verbose output
-uv run pytest -vv
-```
-
-## 🔍 Code Quality
-
-### Linting and Formatting
-
-```bash
-# Check code with ruff
-uv run ruff check
-
-# Fix auto-fixable issues
-uv run ruff check --fix
-
-# Format code
-uv run ruff format
-
-# Check formatting without changing files
-uv run ruff format --check
-```
-
-### Type Checking
-
-```bash
-# Type check the main package
-uv run mypy src/namecheap
-
-# Type check everything (slower)
-uv run mypy src/
-```
-
-### Pre-commit Hooks
-
-The project uses pre-commit hooks to ensure code quality:
-
-```bash
-# Run all pre-commit hooks manually
-pre-commit run --all-files
-
-# Update pre-commit hooks
-pre-commit autoupdate
-```
-
-## 📦 Building and Publishing
-
-### Building Locally
-
-```bash
-# Build distribution packages
-uv build
-
-# This creates:
-# - dist/namecheap-1.0.0-py3-none-any.whl
-# - dist/namecheap-1.0.0.tar.gz
-```
-
-### Release Process
-
-Releases are automated via GitHub Actions:
-
-1. **Manual Release** (via GitHub UI):
-   - Go to Actions → "Bump Version and Release"
-   - Click "Run workflow"
-   - Select version bump type (major/minor/patch)
-   - This will:
-     - Bump version in pyproject.toml
-     - Create git tag
-     - Build and publish to PyPI
-     - Create GitHub release
-
-2. **Tag-based Release**:
-   ```bash
-   # Create and push a tag
-   git tag v1.0.0
-   git push origin v1.0.0
-   ```
-   This triggers the publish workflow automatically.
-
-## 🏗️ Project Structure
-
-```
-namecheap-python/
-├── src/
-│   ├── namecheap/          # Core SDK package
-│   │   ├── __init__.py
-│   │   ├── client.py       # Main client class
-│   │   ├── models.py       # Pydantic models
-│   │   ├── errors.py       # Custom exceptions
-│   │   └── _api/           # API implementations
-│   │       ├── base.py
-│   │       ├── domains.py
-│   │       └── dns.py
-│   ├── namecheap_cli/      # CLI tool
-│   │   ├── __init__.py
-│   │   ├── __main__.py     # CLI entry point
-│   │   └── completion.py   # Shell completions
-│   └── namecheap_dns_tui/  # TUI application
-│       ├── __init__.py
-│       └── __main__.py     # TUI entry point
-├── tests/                  # Test suite
-├── examples/               # Usage examples
-└── docs/                   # Documentation
-```
-
-## 🧩 Adding New Features
-
-### Adding a New API Endpoint
-
-1. Create model in `src/namecheap/models.py`:
-   ```python
-   class NewFeature(BaseModel):
-       field: str
-       another_field: int
-   ```
-
-2. Add API method in appropriate file under `src/namecheap/_api/`:
-   ```python
-   def new_feature(self, param: str) -> NewFeature:
-       """Implement new feature."""
-       response = self._request("namecheap.newfeature.action", {"Param": param})
-       return NewFeature(**response)
-   ```
-
-3. Add tests in `tests/test_newfeature.py`
-
-4. Update documentation
-
-### Adding CLI Commands
-
-1. Add command group or command in `src/namecheap_cli/__main__.py`:
-   ```python
-   @cli.group("newfeature")
-   def newfeature_group():
-       """New feature commands."""
-       pass
-   
-   @newfeature_group.command("action")
-   @click.argument("param")
-   @pass_config
-   def newfeature_action(config: Config, param: str):
-       """Perform new feature action."""
-       nc = config.init_client()
-       result = nc.newfeature.action(param)
-       # Handle output
-   ```
-
-2. Add tests and update CLI documentation
-
-## 🐛 Debugging
-
-### Enable Debug Logging
-
-```python
-import logging
-logging.basicConfig(level=logging.DEBUG)
-
-# Or set environment variable
-export NAMECHEAP_DEBUG=true
-```
-
-### Common Issues
-
-1. **Import errors**: Make sure you're using `uv run` or have activated the virtual environment
-2. **API errors**: Check credentials and sandbox mode settings
-3. **Type errors**: Run `mypy` to catch type issues early
-
-## 📋 Checklist for PRs
-
-- [ ] Code follows project style (run `uv run ruff check`)
-- [ ] All tests pass (`uv run pytest`)
-- [ ] Type hints added (`uv run mypy src/namecheap`)
-- [ ] Documentation updated if needed
-- [ ] Examples work correctly
-- [ ] Commit messages are clear and descriptive
-
-## 🔗 Useful Links
-
-- [Namecheap API Documentation](https://www.namecheap.com/support/api/methods/)
-- [Python Type Hints](https://docs.python.org/3/library/typing.html)
-- [Pydantic Documentation](https://docs.pydantic.dev/)
-- [Click Documentation](https://click.palletsprojects.com/)
-- [Textual Documentation](https://textual.textualize.io/)
-- [Ruff Documentation](https://docs.astral.sh/ruff/)

namecheap_python-1.1.0/pending.md

@@ -1,94 +0,0 @@
-# Pending Features from Previous SDK
-
-Based on the previous Namecheap Python SDK implementation, here's what's still pending in our new clean architecture:
-
-## 🚧 Not Yet Implemented
-
-### 1. **SSL API** (`namecheap.ssl.*`)
-- `create()` - Purchase SSL certificates
-- `activate()` - Activate SSL certificates
-- `getInfo()` - Get SSL certificate details
-- `parseCSR()` - Parse Certificate Signing Request
-- `getApproverEmailList()` - Get domain control validation emails
-- `resendApproverEmail()` - Resend DCV email
-- `reissue()` - Reissue SSL certificate
-- `renew()` - Renew SSL certificate
-- `revoke()` - Revoke SSL certificate
-- `getList()` - List SSL certificates
-
-### 2. **Users API** (`namecheap.users.*`)
-- `getBalances()` - Get account balance
-- `changePassword()` - Change account password
-- `update()` - Update user information
-- `createAddFundsRequest()` - Create add funds request
-- `getAddFundsStatus()` - Check add funds status
-- `create()` - Create sub-account (resellers)
-- `login()` - Login to get session
-- `resetPassword()` - Reset password
-
-### 3. **Domains Transfer API** (`namecheap.domains.transfer.*`)
-- `create()` - Initiate domain transfer
-- `getStatus()` - Check transfer status
-- `updateStatus()` - Approve/reject transfer
-- `getList()` - List pending transfers
-
-### 4. **Domains NS API** (`namecheap.domains.ns.*`) — Glue Records
-- `create()` - Register a child nameserver (e.g., ns1.yourdomain.com → 1.2.3.4)
-- `delete()` - Delete a child nameserver
-- `getInfo()` - Get child nameserver details
-- `update()` - Update child nameserver IP
-
-### 5. **Whois API** (`namecheap.whois.*`)
-- `getWhoisInfo()` - Get WHOIS information
-
-### 6. **Domains Forwarding API**
-- `setEmailForwarding()` - Configure email forwarding
-- `getEmailForwarding()` - Get email forwarding settings
-
-## ✅ Already Implemented (Core Features)
-
-### Domains API
-- ✅ `check()` - Check domain availability
-- ✅ `list()` - List domains in account
-- ✅ `register()` - Register new domain
-- ✅ `renew()` - Renew domain
-- ✅ `setContacts()` - Update contact information
-- ✅ `lock()`/`unlock()` - Domain locking
-
-### DNS API
-- ✅ `get()` - Get DNS records
-- ✅ `set()` - Set DNS records (with builder pattern!)
-- ✅ `add()` - Add single record
-- ✅ `delete()` - Delete records
-- ✅ `set_custom_nameservers()` - Switch to custom nameservers (e.g., Route 53)
-- ✅ `set_default_nameservers()` - Reset to Namecheap BasicDNS
-- ✅ `get_nameservers()` - Get current nameserver configuration
-
-### Enhanced Features
-- ✅ Smart IP detection and validation
-- ✅ Helpful error messages with IP troubleshooting
-- ✅ Pydantic models with proper type safety
-- ✅ Rich logging with colors
-- ✅ Context manager support
-- ✅ DNS builder pattern
-
-## 🔧 Pricing Implementation Status
-
-### Current Issues
-- The `getPricing` API call is implemented but needs debugging
-- Price fields are properly modeled but not being populated correctly
-- Need to verify the API path and response structure for pricing
-
-### Enhanced Domain Check (from old SDK)
-The old SDK had an enhanced domain check that fetched pricing automatically. We've implemented this with the `include_pricing=True` parameter, but it needs fixing.
-
-## 📝 Notes
-
-The core domain and DNS functionality is complete and working well. The additional APIs (SSL, transfers, user management) are less commonly used but would make the SDK feature-complete with the Namecheap API.
-
-Priority for implementation:
-1. Fix pricing retrieval (high - already partially implemented)
-2. SSL API (medium - common use case)
-3. Transfer API (medium - needed for domain transfers)
-4. Users API pricing methods (medium - already have getPricing)
-5. Other APIs (low - rarely used)