namecheap-python-sdk 0.1.0__py3-none-any.whl

namecheap_sdk/client.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._base import AsyncClient, Call, SyncClient
+from .models import Balances
+from .resources import DNS, AsyncDNS, AsyncDomains, Domains
+
+
+class Namecheap(SyncClient):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.domains = Domains(self)
+        self.dns = DNS(self)
+
+    def balances(self) -> Balances:
+        result: Balances = self._execute(Call(self.settings.command("balances"), parse=Balances.from_xml))
+        return result
+
+
+class AsyncNamecheap(AsyncClient):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.domains = AsyncDomains(self)
+        self.dns = AsyncDNS(self)
+
+    async def balances(self) -> Balances:
+        result: Balances = await self._execute(Call(self.settings.command("balances"), parse=Balances.from_xml))
+        return result

namecheap_sdk/config.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from goodconf import Field, GoodConf, GoodConfConfigDict
+from pydantic import BaseModel, SecretStr
+
+from ._version import __version__
+from .errors import AuthenticationError
+from .messages import text
+
+
+class Commands(BaseModel):
+    get_hosts: str = "namecheap.domains.dns.getHosts"
+    set_hosts: str = "namecheap.domains.dns.setHosts"
+    get_nameservers: str = "namecheap.domains.dns.getList"
+    set_custom_nameservers: str = "namecheap.domains.dns.setCustom"
+    set_default_nameservers: str = "namecheap.domains.dns.setDefault"
+    list_domains: str = "namecheap.domains.getList"
+    domain_info: str = "namecheap.domains.getInfo"
+    check: str = "namecheap.domains.check"
+    tlds: str = "namecheap.domains.getTldList"
+    get_lock: str = "namecheap.domains.getRegistrarLock"
+    set_lock: str = "namecheap.domains.setRegistrarLock"
+    balances: str = "namecheap.users.getBalances"
+
+
+class Settings(GoodConf):
+    model_config = GoodConfConfigDict(
+        env_prefix="NAMECHEAP_",
+        file_env_var="NAMECHEAP_CONFIG",
+        default_files=["namecheap.toml", "namecheap.yaml", "namecheap.yml", "namecheap.json"],
+        extra="ignore",
+        env_nested_delimiter="__",
+    )
+
+    api_user: str = Field(default="", description=text("settings.api_user"))
+    api_key: SecretStr = Field(default=SecretStr(""), description=text("settings.api_key"))
+    username: Optional[str] = Field(default=None, description=text("settings.username"))
+    client_ip: str = Field(default="", description=text("settings.client_ip"))
+    environment: str = Field(default="production", description=text("settings.environment"))
+    base_url: Optional[str] = Field(default=None, description=text("settings.base_url"))
+    production_url: str = Field(default="https://api.namecheap.com/xml.response",
+                                description=text("settings.production_url"))
+    sandbox_url: str = Field(default="https://api.sandbox.namecheap.com/xml.response",
+                             description=text("settings.sandbox_url"))
+    commands: Commands = Field(default_factory=Commands, description=text("settings.commands"))
+    timeout: float = Field(default=30.0, gt=0, description=text("settings.timeout"))
+    max_retries: int = Field(default=3, ge=0, description=text("settings.max_retries"))
+    max_retry_wait: float = Field(default=60.0, ge=0, description=text("settings.max_retry_wait"))
+    backoff_base: float = Field(default=1.0, ge=0, description=text("settings.backoff_base"))
+    backoff_cap: float = Field(default=16.0, ge=0, description=text("settings.backoff_cap"))
+    page_size: int = Field(default=100, ge=10, le=100, description=text("settings.page_size"))
+    default_ttl: int = Field(default=1800, ge=60, le=60000, description=text("settings.default_ttl"))
+    user_agent: str = Field(default="namecheap-python-sdk/{version}", description=text("settings.user_agent"))
+
+    @property
+    def environments(self) -> dict[str, str]:
+        return {"production": self.production_url, "prod": self.production_url,
+                "sandbox": self.sandbox_url, "test": self.sandbox_url}
+
+    def resolved_base_url(self) -> str:
+        if self.base_url:
+            return self.base_url
+        env = self.environment.strip().lower()
+        if env not in self.environments:
+            raise ValueError(text("error.unknown_environment", environment=env, choices="production, sandbox"))
+        return self.environments[env]
+
+    def command(self, name: str) -> str:
+        return str(getattr(self.commands, name))
+
+    def resolved_user_agent(self) -> str:
+        return self.user_agent.replace("{version}", __version__)
+
+    def require_credentials(self) -> dict[str, str]:
+        user = self.api_user.strip()
+        key = self.api_key.get_secret_value().strip()
+        ip = self.client_ip.strip()
+        if not user or not key or not ip:
+            raise AuthenticationError(text("error.missing_credentials"))
+        return {"ApiUser": user, "ApiKey": key, "UserName": (self.username or user).strip(), "ClientIp": ip}
+
+
+Settings.__doc__ = text("settings.description")
+
+
+def load_settings(config_file: Optional[str] = None, **overrides: Any) -> Settings:
+    given = {key: value for key, value in overrides.items() if value is not None}
+    return Settings(load=True, config_file=config_file, **given)

namecheap_sdk/errors.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+import httpx
+
+
+@dataclass(frozen=True)
+class APIErrorDetail:
+    number: str
+    message: str
+
+
+class NamecheapError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: Optional[int] = None,
+        number: Optional[str] = None,
+        errors: Optional[list[APIErrorDetail]] = None,
+        command: Optional[str] = None,
+        response: Optional[httpx.Response] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.number = number
+        self.errors = errors or []
+        self.command = command
+        self.response = response
+
+    def __str__(self) -> str:
+        parts = []
+        if self.status_code and self.status_code != 200:
+            parts.append(f"[{self.status_code}]")
+        if self.number:
+            parts.append(self.number)
+        parts.append(self.message)
+        if self.command:
+            parts.append(f"({self.command})")
+        return " ".join(parts)
+
+
+class APIConnectionError(NamecheapError):
+    pass
+
+
+class APITimeoutError(APIConnectionError):
+    pass
+
+
+class APIError(NamecheapError):
+    pass
+
+
+class ValidationError(APIError):
+    pass
+
+
+class AuthenticationError(APIError):
+    pass
+
+
+class PermissionDeniedError(APIError):
+    pass
+
+
+class NotFoundError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    def __init__(self, message: str, *, retry_after: Optional[float] = None, **kwargs: Any) -> None:
+        super().__init__(message, **kwargs)
+        self.retry_after = retry_after
+
+
+class ServerError(APIError):
+    pass
+
+
+AUTH_NUMBERS = frozenset({
+    "1010101", "1010102", "1011102", "1010104", "1010105", "1011105", "1030408", "1050900", "1011150",
+    "1017150", "1017105", "1017101", "1017410", "1017411", "1019103", "1016103", "1017103",
+})
+NOT_FOUND_NUMBERS = frozenset({"2019166", "2016166"})
+PERMISSION_NUMBERS = frozenset({"2030166", "4011103"})
+VALIDATION_NUMBERS = frozenset({"3013288", "4013288", "2015278", "3011288"})
+SERVER_NUMBERS = frozenset({"3031510", "3050900", "5050900", "5019169", "5050169", "4022288", "4023330"})
+STATUS_MAP: dict[int, type[APIError]] = {401: AuthenticationError, 403: PermissionDeniedError, 404: NotFoundError}
+
+
+def error_class(number: str, message: str) -> type[APIError]:
+    lowered = message.lower()
+    if "too many requests" in lowered or "rate limit" in lowered:
+        return RateLimitError
+    if number in AUTH_NUMBERS:
+        return AuthenticationError
+    if number in NOT_FOUND_NUMBERS:
+        return NotFoundError
+    if number in PERMISSION_NUMBERS:
+        return PermissionDeniedError
+    if number in VALIDATION_NUMBERS:
+        return ValidationError
+    if number in SERVER_NUMBERS or number.startswith("5"):
+        return ServerError
+    if number.startswith("2"):
+        return ValidationError
+    return APIError
+
+
+def from_details(details: list[APIErrorDetail], command: str, response: Optional[httpx.Response] = None) -> APIError:
+    first = details[0] if details else APIErrorDetail("", "")
+    cls = error_class(first.number, first.message)
+    message = "; ".join(d.message for d in details if d.message) or first.message
+    return cls(message, number=first.number or None, errors=details, command=command,
+               status_code=response.status_code if response is not None else None, response=response)
+
+
+def from_status(response: httpx.Response, command: str) -> APIError:
+    status = response.status_code
+    message = response.reason_phrase or response.text.strip()[:200]
+    if status == 429:
+        header = response.headers.get("Retry-After")
+        try:
+            wait = float(header) if header else None
+        except ValueError:
+            wait = None
+        return RateLimitError(message, retry_after=wait, status_code=status, command=command, response=response)
+    cls = ServerError if status >= 500 else STATUS_MAP.get(status, APIError)
+    return cls(message, status_code=status, command=command, response=response)

namecheap_sdk/messages.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from importlib import resources
+from pathlib import Path
+from typing import Any, Union
+
+import yaml
+
+PathLike = Union[str, Path]
+
+_PACKAGE_FILE = "messages.yaml"
+_catalog: dict[str, str] = {}
+
+
+def _flatten(node: Mapping[str, Any], prefix: str = "") -> dict[str, str]:
+    flat: dict[str, str] = {}
+    for key, value in node.items():
+        path = f"{prefix}{key}"
+        if isinstance(value, Mapping):
+            flat.update(_flatten(value, f"{path}."))
+        else:
+            flat[path] = str(value)
+    return flat
+
+
+def _parse(raw: str) -> dict[str, str]:
+    data = yaml.safe_load(raw) or {}
+    if not isinstance(data, Mapping):
+        raise ValueError("messages file must contain a mapping")
+    return _flatten(data)
+
+
+def _read_packaged() -> dict[str, str]:
+    raw = resources.files(__package__).joinpath(_PACKAGE_FILE).read_text(encoding="utf-8")
+    return _parse(raw)
+
+
+def catalog() -> Mapping[str, str]:
+    if not _catalog:
+        _catalog.update(_read_packaged())
+    return _catalog
+
+
+def use(source: PathLike | Mapping[str, Any]) -> None:
+    if isinstance(source, Mapping):
+        overrides = _flatten(source)
+    else:
+        overrides = _parse(Path(source).read_text(encoding="utf-8"))
+    unknown = set(overrides) - set(_read_packaged())
+    if unknown:
+        raise KeyError(", ".join(sorted(unknown)))
+    catalog()
+    _catalog.update(overrides)
+
+
+def reset() -> None:
+    _catalog.clear()
+
+
+def text(key: str, **params: Any) -> str:
+    template = catalog()[key]
+    return template.format(**params) if params else template

namecheap_sdk/messages.yaml

@@ -0,0 +1,39 @@
+settings:
+  description: Settings for the Namecheap API client.
+  api_user: Account name that owns the API key.
+  api_key: API key from Profile, Tools, Namecheap API Access.
+  username: Account the commands run on. Defaults to api_user.
+  client_ip: Whitelisted IPv4 address of the machine that makes the calls.
+  environment: 'Which Namecheap environment to call: production or sandbox.'
+  base_url: Full API URL. Overrides the environment when set.
+  production_url: API URL used for the production environment.
+  sandbox_url: API URL used for the sandbox environment.
+  commands: Command names sent for every call.
+  timeout: Seconds to wait for a single request.
+  max_retries: How many times a failed request is tried again.
+  max_retry_wait: Longest wait in seconds the client accepts between retries.
+  backoff_base: First backoff delay in seconds, doubled on every retry.
+  backoff_cap: Longest backoff delay in seconds.
+  page_size: Domains asked for on every page when listing, between 10 and 100.
+  default_ttl: TTL in seconds used for new records when none is given.
+  user_agent: User-Agent header. {version} is replaced with the package version.
+error:
+  request_failed: Request failed
+  missing_credentials: Missing credentials. Pass api_user, api_key and client_ip, set NAMECHEAP_API_USER,
+    NAMECHEAP_API_KEY and NAMECHEAP_CLIENT_IP, or point NAMECHEAP_CONFIG at a config file.
+  unknown_environment: 'Unknown environment {environment!r}. Use one of: {choices}.'
+  timeout: 'Request timed out: {error}'
+  connection: 'Connection failed: {error}'
+  not_saved: Namecheap did not confirm the change for {domain}
+  bad_xml: 'Namecheap answered with something that is not valid XML: {error}'
+value:
+  empty_domain: domain must not be empty
+  no_tld: '{domain!r} has no TLD, pass a full domain like example.com'
+  empty_name: record name must not be empty, use '@' for the apex
+  empty_type: record type must not be empty
+  no_values: at least one record value is required
+  add_needs_records: add() needs at least one DNSRecord
+  foreign_name: '{name!r} is not inside {domain}'
+  ttl_range: TTL must be between 60 and 60000 seconds, got {ttl}
+  no_domains: available_many() needs at least one domain
+  nameserver_count: a domain needs at least 2 name servers, got {count}

namecheap_sdk/models.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import ipaddress
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from decimal import Decimal, InvalidOperation
+from enum import Enum
+from typing import Any, Optional, Union
+
+from .messages import text
+
+
+class RecordType(str, Enum):
+    A = "A"
+    AAAA = "AAAA"
+    ALIAS = "ALIAS"
+    CAA = "CAA"
+    CNAME = "CNAME"
+    MX = "MX"
+    MXE = "MXE"
+    NS = "NS"
+    TXT = "TXT"
+    URL = "URL"
+    URL301 = "URL301"
+    FRAME = "FRAME"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+RecordTypeLike = Union[RecordType, str]
+HOST_TYPES = frozenset({"CNAME", "ALIAS", "NS", "MX"})
+
+
+def record_type(value: RecordTypeLike) -> str:
+    kind = value.value if isinstance(value, RecordType) else str(value).strip().upper()
+    if not kind:
+        raise ValueError(text("value.empty_type"))
+    return kind
+
+
+def hostname(value: str) -> str:
+    host = value.strip()
+    if host == "@" or host.endswith(".") or "." not in host:
+        return host
+    return f"{host}."
+
+
+def flag(value: Any) -> bool:
+    return str(value).strip().lower() == "true"
+
+
+def number(value: Any) -> Optional[int]:
+    try:
+        return int(str(value).strip())
+    except (TypeError, ValueError):
+        return None
+
+
+def money(value: Any) -> Optional[Decimal]:
+    if value in (None, ""):
+        return None
+    try:
+        return Decimal(str(value))
+    except InvalidOperation:
+        return None
+
+
+def day(value: Any) -> Optional[date]:
+    if not value:
+        return None
+    try:
+        return datetime.strptime(str(value).strip(), "%m/%d/%Y").date()
+    except ValueError:
+        return None
+
+
+def child_text(element: Optional[ET.Element], path: str) -> Optional[str]:
+    if element is None:
+        return None
+    found = element.find(path)
+    return found.text.strip() if found is not None and found.text else None
+
+
+@dataclass
+class DNSRecord:
+    type: str
+    name: str
+    data: str
+    ttl: Optional[int] = None
+    priority: Optional[int] = None
+    id: Optional[int] = field(default=None, compare=False)
+    active: bool = field(default=True, compare=False)
+
+    def __post_init__(self) -> None:
+        self.type = record_type(self.type)
+        self.name = self.name.strip() or "@"
+
+    @classmethod
+    def a(cls, name: str, ip: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("A", name, str(ipaddress.IPv4Address(ip)), ttl)
+
+    @classmethod
+    def aaaa(cls, name: str, ip: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("AAAA", name, str(ipaddress.IPv6Address(ip)), ttl)
+
+    @classmethod
+    def cname(cls, name: str, target: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("CNAME", name, hostname(target), ttl)
+
+    @classmethod
+    def alias(cls, name: str, target: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("ALIAS", name, hostname(target), ttl)
+
+    @classmethod
+    def txt(cls, name: str, value: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("TXT", name, value, ttl)
+
+    @classmethod
+    def mx(cls, name: str, host: str, priority: int = 10, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("MX", name, hostname(host), ttl, priority=priority)
+
+    @classmethod
+    def ns(cls, name: str, host: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("NS", name, hostname(host), ttl)
+
+    @classmethod
+    def caa(cls, name: str, value: str, tag: str = "issue", flags: int = 0, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("CAA", name, f'{flags} {tag} "{value}"', ttl)
+
+    @classmethod
+    def url(cls, name: str, target: str, *, permanent: bool = True, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("URL301" if permanent else "URL", name, target, ttl)
+
+    @classmethod
+    def frame(cls, name: str, target: str, ttl: Optional[int] = None) -> DNSRecord:
+        return cls("FRAME", name, target, ttl)
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> DNSRecord:
+        kind = element.get("Type", "")
+        return cls(
+            type=kind,
+            name=element.get("Name", "@"),
+            data=element.get("Address", ""),
+            ttl=number(element.get("TTL")),
+            priority=number(element.get("MXPref")) if kind.upper() in ("MX", "MXE") else None,
+            id=number(element.get("HostId")),
+            active=element.get("IsActive", "true").lower() != "false",
+        )
+
+    def fqdn(self, domain: str) -> str:
+        return domain if self.name == "@" else f"{self.name}.{domain}"
+
+
+@dataclass
+class Hosts:
+    domain: str
+    records: list[DNSRecord] = field(default_factory=list)
+    using_our_dns: bool = True
+    email_type: Optional[str] = None
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Hosts:
+        result = element.find("DomainDNSGetHostsResult")
+        node = result if result is not None else element
+        email = node.get("EmailType")
+        return cls(
+            domain=node.get("Domain", ""),
+            records=[DNSRecord.from_xml(host) for host in node.iter("host")]
+            + [DNSRecord.from_xml(host) for host in node.iter("Host")],
+            using_our_dns=flag(node.get("IsUsingOurDNS", "true")),
+            email_type=email.upper() if email else None,
+        )
+
+
+@dataclass
+class Domain:
+    name: str
+    id: Optional[int] = None
+    user: str = ""
+    created: Optional[date] = None
+    expires: Optional[date] = None
+    is_expired: bool = False
+    is_locked: bool = False
+    auto_renew: bool = False
+    whois_guard: str = ""
+    is_premium: bool = False
+    is_our_dns: bool = False
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Domain:
+        return cls(
+            name=element.get("Name", ""),
+            id=number(element.get("ID")),
+            user=element.get("User", ""),
+            created=day(element.get("Created")),
+            expires=day(element.get("Expires")),
+            is_expired=flag(element.get("IsExpired")),
+            is_locked=flag(element.get("IsLocked")),
+            auto_renew=flag(element.get("AutoRenew")),
+            whois_guard=element.get("WhoisGuard", ""),
+            is_premium=flag(element.get("IsPremium")),
+            is_our_dns=flag(element.get("IsOurDNS")),
+        )
+
+
+@dataclass
+class DomainInfo:
+    name: str
+    id: Optional[int] = None
+    status: str = ""
+    owner: str = ""
+    is_owner: bool = False
+    is_premium: bool = False
+    created: Optional[date] = None
+    expires: Optional[date] = None
+    whois_guard: bool = False
+    dns_provider: str = ""
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> DomainInfo:
+        result = element.find("DomainGetInfoResult")
+        node = result if result is not None else element
+        guard = node.find("Whoisguard")
+        dns = node.find("DnsDetails")
+        return cls(
+            name=node.get("DomainName", ""),
+            id=number(node.get("ID")),
+            status=node.get("Status", ""),
+            owner=node.get("OwnerName", ""),
+            is_owner=flag(node.get("IsOwner")),
+            is_premium=flag(node.get("IsPremium")),
+            created=day(child_text(node, "DomainDetails/CreatedDate")),
+            expires=day(child_text(node, "DomainDetails/ExpiredDate")),
+            whois_guard=flag(guard.get("Enabled")) if guard is not None else False,
+            dns_provider=dns.get("ProviderType", "") if dns is not None else "",
+        )
+
+
+@dataclass
+class Availability:
+    domain: str
+    available: bool
+    premium: bool = False
+    registration_price: Optional[Decimal] = None
+    renewal_price: Optional[Decimal] = None
+    restore_price: Optional[Decimal] = None
+    transfer_price: Optional[Decimal] = None
+    icann_fee: Optional[Decimal] = None
+    eap_fee: Optional[Decimal] = None
+    description: str = ""
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Availability:
+        premium = flag(element.get("IsPremiumName"))
+        return cls(
+            domain=element.get("Domain", ""),
+            available=flag(element.get("Available")),
+            premium=premium,
+            registration_price=money(element.get("PremiumRegistrationPrice")) if premium else None,
+            renewal_price=money(element.get("PremiumRenewalPrice")) if premium else None,
+            restore_price=money(element.get("PremiumRestorePrice")) if premium else None,
+            transfer_price=money(element.get("PremiumTransferPrice")) if premium else None,
+            icann_fee=money(element.get("IcannFee")),
+            eap_fee=money(element.get("EapFee")),
+            description=element.get("Description", ""),
+        )
+
+
+@dataclass
+class Tld:
+    name: str
+    description: str = ""
+    type: str = ""
+    min_years: Optional[int] = None
+    max_years: Optional[int] = None
+    api_registerable: bool = False
+    api_renewable: bool = False
+    api_transferable: bool = False
+    supports_idn: bool = False
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Tld:
+        return cls(
+            name=element.get("Name", ""),
+            description=(element.text or "").strip(),
+            type=element.get("Type", ""),
+            min_years=number(element.get("MinRegisterYears")),
+            max_years=number(element.get("MaxRegisterYears")),
+            api_registerable=flag(element.get("IsApiRegisterable")),
+            api_renewable=flag(element.get("IsApiRenewable")),
+            api_transferable=flag(element.get("IsApiTransferable")),
+            supports_idn=flag(element.get("IsSupportsIDN")),
+        )
+
+
+@dataclass
+class Nameservers:
+    domain: str
+    servers: list[str] = field(default_factory=list)
+    using_our_dns: bool = True
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Nameservers:
+        result = element.find("DomainDNSGetListResult")
+        node = result if result is not None else element
+        return cls(
+            domain=node.get("Domain", ""),
+            servers=[(ns.text or "").strip() for ns in node.iter("Nameserver") if ns.text],
+            using_our_dns=flag(node.get("IsUsingOurDNS", "true")),
+        )
+
+
+@dataclass
+class Balances:
+    currency: str
+    available: Optional[Decimal] = None
+    account: Optional[Decimal] = None
+    earned: Optional[Decimal] = None
+    withdrawable: Optional[Decimal] = None
+    required_for_auto_renew: Optional[Decimal] = None
+
+    @classmethod
+    def from_xml(cls, element: ET.Element) -> Balances:
+        result = element.find("UserGetBalancesResult")
+        node = result if result is not None else element
+        return cls(
+            currency=node.get("Currency", ""),
+            available=money(node.get("AvailableBalance")),
+            account=money(node.get("AccountBalance")),
+            earned=money(node.get("EarnedAmount")),
+            withdrawable=money(node.get("WithdrawableAmount")),
+            required_for_auto_renew=money(node.get("FundsRequiredForAutoRenew")),
+        )