hrd-py 0.0.1__tar.gz

hrd_py-0.0.1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: hrd-py
+Version: 0.0.1
+Summary: A Python library and CLI for the HRD.pl API
+Author: TheUndefined
+License: MIT
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: mypy>=1.9.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# hrd-py
+
+A Python library and CLI for the HRD.pl API.
+
+## Features
+- Check account balance.
+- List domains and their status.
+- Monitor domain expiry.
+- Renew domains manually or automatically.
+
+## Installation
+```bash
+pip install .
+```
+
+## Configuration
+Create a `.env` file with your HRD.pl credentials:
+```env
+HRD_LOGIN=your_login
+HRD_PASS=your_api_password
+HRD_HASH=your_api_hash
+```
+
+## Usage
+### CLI
+```bash
+hrd balance
+hrd domains --all
+hrd expiring --days 30
+hrd renew example.com
+hrd auto-renew --days 7
+```
+
+### Library
+```python
+from hrd_py import HRDClient
+
+client = HRDClient(login, password, api_hash)
+client.login()
+balance = client.get_balance()
+print(f"Balance: {balance.balance}")
+```

hrd_py-0.0.1/README.md

@@ -0,0 +1,42 @@
+# hrd-py
+
+A Python library and CLI for the HRD.pl API.
+
+## Features
+- Check account balance.
+- List domains and their status.
+- Monitor domain expiry.
+- Renew domains manually or automatically.
+
+## Installation
+```bash
+pip install .
+```
+
+## Configuration
+Create a `.env` file with your HRD.pl credentials:
+```env
+HRD_LOGIN=your_login
+HRD_PASS=your_api_password
+HRD_HASH=your_api_hash
+```
+
+## Usage
+### CLI
+```bash
+hrd balance
+hrd domains --all
+hrd expiring --days 30
+hrd renew example.com
+hrd auto-renew --days 7
+```
+
+### Library
+```python
+from hrd_py import HRDClient
+
+client = HRDClient(login, password, api_hash)
+client.login()
+balance = client.get_balance()
+print(f"Balance: {balance.balance}")
+```

hrd_py-0.0.1/hrd_py/api.py

@@ -0,0 +1,208 @@
+import socket
+import ssl
+import hashlib
+import struct
+import xml.etree.ElementTree as ET
+from typing import Optional, List, Dict, Any
+from .exceptions import HRDCommunicationError, HRDAPIError, HRDAuthError
+
+
+class HRDApi:
+    def __init__(
+        self,
+        api_login: str,
+        api_pass: str,
+        api_hash: str,
+        host: str = "api.hrd.pl",
+        port: int = 9999,
+        timeout: int = 10,
+        verify_peer: bool = True,
+    ):
+        self.api_login = api_login
+        self.api_pass = api_pass
+        self.api_hash = bytes.fromhex(api_hash)
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.verify_peer = verify_peer
+
+        self.token: Optional[str] = None
+        self._sock: Optional[socket.socket] = None
+        self._ssl_sock: Optional[ssl.SSLSocket] = None
+
+    def _connect(self):
+        if self._ssl_sock:
+            return
+
+        try:
+            self._sock = socket.create_connection((self.host, self.port), timeout=self.timeout)
+            context = ssl.create_default_context()
+            if not self.verify_peer:
+                context.check_hostname = False
+                context.verify_mode = ssl.CERT_NONE
+
+            self._ssl_sock = context.wrap_socket(self._sock, server_hostname=self.host)
+        except Exception as e:
+            raise HRDCommunicationError(f"Failed to connect to {self.host}:{self.port}: {e}")
+
+    def _disconnect(self):
+        if self._ssl_sock:
+            self._ssl_sock.close()
+            self._ssl_sock = None
+        if self._sock:
+            self._sock.close()
+            self._sock = None
+
+    def _send(self, xml_data: str):
+        self._connect()
+        assert self._ssl_sock is not None
+
+        # Calculate hash: SHA512(XML + binary_api_hash)
+        # Note: XML must be the exact string, including any whitespace or lack thereof
+        payload_bytes = xml_data.encode("utf-8")
+        h = hashlib.sha512()
+        h.update(payload_bytes)
+        h.update(self.api_hash)
+        hash_bytes = h.digest()
+
+        full_payload = hash_bytes + payload_bytes
+        length_prefix = struct.pack(">I", len(full_payload))
+
+        try:
+            self._ssl_sock.sendall(length_prefix + full_payload)
+        except Exception as e:
+            self._disconnect()
+            raise HRDCommunicationError(f"Failed to send data: {e}")
+
+    def _read(self) -> str:
+        assert self._ssl_sock is not None
+        try:
+            length_data = self._ssl_sock.recv(4)
+            if len(length_data) < 4:
+                raise HRDCommunicationError("Failed to read response length")
+
+            length = struct.unpack(">I", length_data)[0]
+            response_data = b""
+            while len(response_data) < length:
+                chunk = self._ssl_sock.recv(length - len(response_data))
+                if not chunk:
+                    break
+                response_data += chunk
+
+            if len(response_data) != length:
+                raise HRDCommunicationError(f"Expected {length} bytes, got {len(response_data)}")
+
+            return response_data.decode("utf-8")
+        except Exception as e:
+            self._disconnect()
+            raise HRDCommunicationError(f"Failed to read response: {e}")
+
+    def _request(self, module: str, method: str = "", params: Optional[Dict[str, Any]] = None) -> ET.Element:
+        # Construct XML - mirror PHP DOMDocument behavior
+        # PHP: $dom = new \DOMDocument('1.0', 'utf-8');
+        # PHP: $api = $dom->createElementNS('http://api.hrd.pl/api/', 'api');
+
+        # We'll use a manual XML string to be safe about formatting, or carefully use ET
+        root = ET.Element("api", xmlns="http://api.hrd.pl/api/")
+
+        # NOTE: Token is NOT included in normal requests in PHP library!
+        # It's only used in loginByToken method which sends <api><token>...</token></api>
+
+        module_elem = ET.SubElement(root, module)
+        if method:
+            target_elem = ET.SubElement(module_elem, method)
+        else:
+            target_elem = module_elem
+
+        if params:
+            self._dict_to_xml(target_elem, params)
+
+        # PHP's saveXML() usually includes the XML declaration and some whitespace
+        # but the schema validation might depend on it.
+        # Let's try without declaration first as we did before, but with encoding="utf-8"
+        xml_str = ET.tostring(root, encoding="unicode")
+
+        self._send(xml_str)
+
+        response_xml = self._read()
+        # The PHP code removes the xmlns before parsing
+        response_xml = response_xml.replace('xmlns="http://api.hrd.pl/api/"', "")
+
+        resp_root = ET.fromstring(response_xml)
+
+        # Check for error
+        error_msg = resp_root.find("message")
+        if error_msg is not None:
+            raise HRDAPIError(error_msg.text)
+
+        status = resp_root.find("status")
+        if status is not None and status.text == "error":
+            raise HRDAPIError("API returned error status")
+
+        return resp_root
+
+    def _dict_to_xml(self, parent, data: Dict[str, Any]):
+        for key, value in data.items():
+            child = ET.SubElement(parent, key)
+            if isinstance(value, dict):
+                self._dict_to_xml(child, value)
+            elif isinstance(value, list):
+                pass
+            else:
+                child.text = str(value)
+
+    def login(self, login_type: str = "partnerApi"):
+        params = {"login": self.api_login, "pass": self.api_pass, "type": login_type}
+        resp = self._request("login", "", params)
+
+        token = resp.find("token")
+        if token is not None:
+            self.token = token.text
+            return self.token
+        raise HRDAuthError("Login failed, no token received")
+
+    def partner_get_balance(self) -> Dict[str, float]:
+        resp = self._request("partner", "getBalance")
+        balance_elem = resp.find(".//getBalance")
+        if balance_elem is None:
+            balance_elem = resp.find(".//partner/getBalance")
+
+        if balance_elem is not None:
+            balance_child = balance_elem.find("balance")
+            restricted_child = balance_elem.find("restrictedBalance")
+            if balance_child is not None and balance_child.text is not None:
+                if restricted_child is not None and restricted_child.text is not None:
+                    return {
+                        "balance": float(balance_child.text),
+                        "restricted_balance": float(restricted_child.text),
+                    }
+        raise HRDAPIError("Could not find balance information in response")
+
+    def domain_list(self, last_name: Optional[str] = None) -> List[str]:
+        params = {}
+        if last_name:
+            params["lastName"] = last_name
+
+        resp = self._request("domain", "list", params)
+        names = resp.findall(".//domain/list/name")
+        return [n.text for n in names if n.text is not None]
+
+    def domain_info(self, domain_name: str) -> Dict[str, Any]:
+        params = {"name": domain_name}
+        resp = self._request("domain", "info", params)
+        info_elem = resp.find(".//domain/info")
+
+        if info_elem is not None:
+            info = {}
+            for child in info_elem:
+                info[child.tag] = child.text
+            return info
+        raise HRDAPIError(f"Could not find info for domain {domain_name}")
+
+    def domain_renew(self, domain_name: str, current_expiry_date: str, period: int = 1) -> int:
+        params = {"name": domain_name, "currentExpirationDate": current_expiry_date, "period": period}
+        resp = self._request("domain", "renew", params)
+        action_id = resp.find(".//domain/renew/actionId")
+        if action_id is not None and action_id.text is not None:
+            return int(action_id.text)
+        raise HRDAPIError(f"Renewal failed for domain {domain_name}")

hrd_py-0.0.1/hrd_py/cli.py

@@ -0,0 +1,205 @@
+import os
+import sys
+import click
+from .client import HRDClient
+from .exceptions import HRDError
+from .config import ConfigManager
+from dotenv import load_dotenv
+
+# Still load dotenv for backward compatibility or explicit override
+load_dotenv(override=True)
+
+
+class CLIContext:
+    def __init__(self, profile=None):
+        self.config_manager = ConfigManager()
+        self.profile_name = profile or self.config_manager.get_default_profile_name()
+        self._client = None
+
+    def get_client(self):
+        if self._client:
+            return self._client
+
+        # 1. Try from config
+        profile = self.config_manager.get_profile(self.profile_name)
+        if profile:
+            self._client = HRDClient(profile["login"], profile["password"], profile["api_hash"])
+            return self._client
+
+        # 2. Fallback to ENV (only if no specific profile requested)
+        if not self.profile_name or self.profile_name == self.config_manager.get_default_profile_name():
+            login = os.getenv("HRD_LOGIN")
+            password = os.getenv("HRD_PASS")
+            api_hash = os.getenv("HRD_HASH")
+
+            if all([login, password, api_hash]):
+                self._client = HRDClient(login, password, api_hash)
+                return self._client
+
+        click.echo(f"Error: Missing configuration for profile '{self.profile_name or 'default'}'.")
+        click.echo("Use 'hrd profile add' to set up credentials.")
+        sys.exit(1)
+
+
+@click.group()
+@click.option("--profile", help="Use a specific profile from config")
+@click.pass_context
+def cli(ctx, profile):
+    """HRD.pl API Command Line Interface"""
+    ctx.obj = CLIContext(profile)
+
+
+@cli.group()
+def profile():
+    """Manage account profiles"""
+    pass
+
+
+@profile.command(name="add")
+@click.argument("name")
+@click.option("--login", prompt=True, help="HRD API Login")
+@click.option("--password", prompt=True, hide_input=True, help="HRD API Password")
+@click.option("--hash", prompt=True, help="HRD API Hash")
+@click.pass_obj
+def profile_add(obj, name, login, password, hash):
+    """Add a new profile"""
+    obj.config_manager.add_profile(name, login, password, hash)
+    click.echo(f"Profile '{name}' added successfully.")
+
+
+@profile.command(name="list")
+@click.pass_obj
+def profile_list(obj):
+    """List all configured profiles"""
+    profiles = obj.config_manager.list_profiles()
+    default = obj.config_manager.get_default_profile_name()
+    if not profiles:
+        click.echo("No profiles configured.")
+        return
+    for p in profiles:
+        star = "*" if p == default else " "
+        click.echo(f"{star} {p}")
+
+
+@profile.command(name="set-default")
+@click.argument("name")
+@click.pass_obj
+def profile_set_default(obj, name):
+    """Set a profile as default"""
+    if obj.config_manager.set_default(name):
+        click.echo(f"Default profile set to '{name}'.")
+    else:
+        click.echo(f"Error: Profile '{name}' not found.")
+
+
+@cli.command()
+@click.pass_obj
+def balance(obj):
+    """Show account balance"""
+    client = obj.get_client()
+    try:
+        client.login()
+        b = client.get_balance()
+        click.echo(f"Profile: {obj.profile_name or 'default'}")
+        click.echo(f"Current Balance: {b.balance}")
+        click.echo(f"Restricted Balance: {b.restricted_balance}")
+    except HRDError as e:
+        click.echo(f"Error: {e}")
+
+
+@cli.command()
+@click.option("--all", is_flag=True, help="List all domains, not just expiring")
+@click.option("--days", default=30, help="Days until expiry for filtering")
+@click.pass_obj
+def domains(obj, all, days):
+    """List domains and their status"""
+    client = obj.get_client()
+    try:
+        client.login()
+        click.echo(f"Fetching domains for {obj.profile_name or 'default'}...")
+        domains = client.list_domains()
+
+        for d in domains:
+            if all or d.is_expiring_soon(days):
+                expiry_str = d.expiry_date.strftime("%Y-%m-%d") if d.expiry_date else "Unknown"
+                status_str = click.style(d.status, fg="red" if d.status == "expired" else "green")
+                click.echo(f"{d.name:30} | {expiry_str:10} | {status_str}")
+    except HRDError as e:
+        click.echo(f"Error: {e}")
+
+
+@cli.command()
+@click.argument("domain")
+@click.option("--period", default=1, help="Renewal period in years")
+@click.pass_obj
+def renew(obj, domain, period):
+    """Renew a specific domain"""
+    client = obj.get_client()
+    try:
+        client.login()
+        click.echo(f"Renewing domain {domain} for {period} year(s)...")
+        action_id = client.renew_domain(domain, period)
+        click.echo(f"Success! Action ID: {action_id}")
+    except HRDError as e:
+        click.echo(f"Error: {e}")
+
+
+@cli.command()
+@click.option("--days", default=30, help="Days until expiry for automatic renewal")
+@click.option("--dry-run", is_flag=True, help="Don't actually perform renewal")
+@click.option("--interactive", "-i", is_flag=True, help="Confirm each domain before renewal")
+@click.option("--all-profiles", is_flag=True, help="Process all configured profiles")
+@click.pass_obj
+def auto_renew(obj, days, dry_run, interactive, all_profiles):
+    """Automatically renew expiring domains"""
+
+    profiles_to_process = []
+    if all_profiles:
+        profiles_to_process = obj.config_manager.list_profiles()
+        if not profiles_to_process:
+            # If no profiles in config, check if we have ENV vars as a pseudo-profile
+            if os.getenv("HRD_LOGIN"):
+                profiles_to_process = [None]  # Use default/env logic
+    else:
+        profiles_to_process = [obj.profile_name]
+
+    for p_name in profiles_to_process:
+        # Create a fresh context for each profile if processing all
+        if all_profiles:
+            ctx_profile = CLIContext(p_name)
+        else:
+            ctx_profile = obj
+
+        click.echo(f"\n--- Processing profile: {p_name or 'default'} ---")
+        try:
+            client = ctx_profile.get_client()
+            client.login()
+            click.echo(f"Checking for domains expiring within {days} days...")
+            domains = client.list_domains()
+            expiring = [d for d in domains if d.is_expiring_soon(days)]
+
+            if not expiring:
+                click.echo("No domains found for renewal.")
+                continue
+
+            for d in expiring:
+                if dry_run:
+                    click.echo(f"[DRY RUN] Would renew {d.name}")
+                else:
+                    if interactive:
+                        if not click.confirm(f"Renew {d.name}?", default=False):
+                            click.echo(f"Skipping {d.name}")
+                            continue
+
+                    click.echo(f"Renewing {d.name}...")
+                    try:
+                        action_id = client.renew_domain(d.name)
+                        click.echo(f"  Success: {action_id}")
+                    except HRDError as e:
+                        click.echo(f"  Failed: {e}")
+        except Exception as e:
+            click.echo(f"Error processing profile {p_name or 'default'}: {e}")
+
+
+if __name__ == "__main__":
+    cli()

hrd_py-0.0.1/hrd_py/client.py

@@ -0,0 +1,85 @@
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from .api import HRDApi
+from .models import Balance, Domain
+from .exceptions import HRDError
+
+
+class HRDClient:
+    def __init__(self, api_login: str, api_pass: str, api_hash: str, **kwargs):
+        self.api = HRDApi(api_login, api_pass, api_hash, **kwargs)
+
+    def login(self) -> str:
+        return self.api.login()
+
+    def get_balance(self) -> Balance:
+        data = self.api.partner_get_balance()
+        return Balance(balance=data["balance"], restricted_balance=data["restricted_balance"])
+
+    def list_domains(self) -> List[Domain]:
+        domain_names = []
+        last_name = None
+        while True:
+            batch = self.api.domain_list(last_name=last_name)
+            if not batch:
+                break
+            domain_names.extend(batch)
+            last_name = batch[-1]
+            # HRD API doesn't seem to have a defined limit per page in PHP code,
+            # but usually it's limited. If we get the same last_name, we break to avoid infinite loop.
+            if len(batch) < 2:  # Very simple check for small batch
+                break
+
+        domains = []
+        for name in domain_names:
+            try:
+                info = self.api.domain_info(name)
+                domains.append(self._parse_domain_info(name, info))
+            except HRDError:
+                # If info fails for one domain, we might still want to continue
+                domains.append(Domain(name=name, status="unknown"))
+
+        return domains
+
+    def _parse_domain_info(self, name: str, info: Dict[str, Any]) -> Domain:
+        expiry_date = None
+        if info.get("exDate"):
+            expiry_date = self._parse_date(info["exDate"])
+
+        create_date = None
+        if info.get("crDate"):
+            create_date = self._parse_date(info["crDate"])
+
+        return Domain(name=name, status=info.get("status", "unknown"), expiry_date=expiry_date, create_date=create_date)
+
+    def _parse_date(self, date_str: str) -> Optional[datetime]:
+        for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d"):
+            try:
+                return datetime.strptime(date_str, fmt)
+            except ValueError:
+                continue
+        return None
+
+    def renew_domain(self, domain_name: str, period: int = 1) -> int:
+        info = self.api.domain_info(domain_name)
+        if not info.get("exDate"):
+            raise HRDError(f"Cannot renew domain {domain_name}: expiry date unknown")
+
+        expiry_date = self._parse_date(info["exDate"])
+        if not expiry_date:
+            raise HRDError(f"Cannot renew domain {domain_name}: unparseable expiry date '{info['exDate']}'")
+
+        # API requires currentExpirationDate as a plain YYYY-MM-DD date (no time component)
+        return self.api.domain_renew(domain_name, expiry_date.strftime("%Y-%m-%d"), period)
+
+    def renew_all_expiring(self, days: int = 30) -> Dict[str, int]:
+        domains = self.list_domains()
+        results = {}
+        for domain in domains:
+            if domain.is_expiring_soon(days):
+                try:
+                    action_id = self.renew_domain(domain.name)
+                    results[domain.name] = action_id
+                except HRDError:
+                    results[domain.name] = -1  # or error message
+        return results

hrd_py-0.0.1/hrd_py/config.py

@@ -0,0 +1,63 @@
+import os
+import yaml
+import stat
+from typing import Dict, Any, Optional, List
+
+
+class ConfigManager:
+    DEFAULT_PATH = os.path.expanduser("~/.config/hrd/config.yaml")
+
+    def __init__(self, path: Optional[str] = None):
+        self.path = path or self.DEFAULT_PATH
+        self.config: Dict[str, Any] = {"default_profile": None, "profiles": {}}
+        self.load()
+
+    def load(self):
+        if os.path.exists(self.path):
+            with open(self.path, "r") as f:
+                loaded = yaml.safe_load(f)
+                if loaded:
+                    self.config.update(loaded)
+
+    def save(self):
+        dirname = os.path.dirname(self.path)
+        if dirname:
+            os.makedirs(dirname, exist_ok=True)
+        with open(self.path, "w") as f:
+            yaml.safe_dump(self.config, f)
+
+        # Set secure permissions (600)
+        os.chmod(self.path, stat.S_IRUSR | stat.S_IWUSR)
+
+    def get_profile(self, name: Optional[str] = None) -> Optional[Dict[str, str]]:
+        name = name or self.config.get("default_profile")
+        if not name:
+            return None
+        return self.config.get("profiles", {}).get(name)
+
+    def add_profile(self, name: str, login: str, password: str, api_hash: str):
+        if "profiles" not in self.config:
+            self.config["profiles"] = {}
+
+        self.config["profiles"][name] = {"login": login, "password": password, "api_hash": api_hash}
+
+        if not self.config.get("default_profile"):
+            self.config["default_profile"] = name
+
+        self.save()
+
+    def set_default(self, name: str):
+        if name in self.config.get("profiles", {}):
+            self.config["default_profile"] = name
+            self.save()
+            return True
+        return False
+
+    def list_profiles(self) -> List[str]:
+        return list(self.config.get("profiles", {}).keys())
+
+    def get_all_profiles(self) -> Dict[str, Dict[str, str]]:
+        return self.config.get("profiles", {})
+
+    def get_default_profile_name(self) -> Optional[str]:
+        return self.config.get("default_profile")

hrd_py-0.0.1/hrd_py/exceptions.py

@@ -0,0 +1,24 @@
+class HRDError(Exception):
+    """Base exception for hrd-py"""
+
+    pass
+
+
+class HRDCommunicationError(HRDError):
+    """Exception raised for communication errors with HRD API"""
+
+    pass
+
+
+class HRDAuthError(HRDError):
+    """Exception raised for authentication errors"""
+
+    pass
+
+
+class HRDAPIError(HRDError):
+    """Exception raised when the API returns an error message"""
+
+    def __init__(self, message, code=None):
+        super().__init__(message)
+        self.code = code

hrd_py-0.0.1/hrd_py/models.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class Balance:
+    balance: float
+    restricted_balance: float
+
+
+@dataclass
+class Domain:
+    name: str
+    status: str
+    expiry_date: Optional[datetime] = None
+    create_date: Optional[datetime] = None
+
+    def is_expiring_soon(self, days: int = 30) -> bool:
+        if not self.expiry_date:
+            return False
+        delta = self.expiry_date - datetime.now()
+        return delta.days <= days

hrd_py-0.0.1/hrd_py.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: hrd-py
+Version: 0.0.1
+Summary: A Python library and CLI for the HRD.pl API
+Author: TheUndefined
+License: MIT
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: mypy>=1.9.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+
+# hrd-py
+
+A Python library and CLI for the HRD.pl API.
+
+## Features
+- Check account balance.
+- List domains and their status.
+- Monitor domain expiry.
+- Renew domains manually or automatically.
+
+## Installation
+```bash
+pip install .
+```
+
+## Configuration
+Create a `.env` file with your HRD.pl credentials:
+```env
+HRD_LOGIN=your_login
+HRD_PASS=your_api_password
+HRD_HASH=your_api_hash
+```
+
+## Usage
+### CLI
+```bash
+hrd balance
+hrd domains --all
+hrd expiring --days 30
+hrd renew example.com
+hrd auto-renew --days 7
+```
+
+### Library
+```python
+from hrd_py import HRDClient
+
+client = HRDClient(login, password, api_hash)
+client.login()
+balance = client.get_balance()
+print(f"Balance: {balance.balance}")
+```

hrd_py-0.0.1/hrd_py.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+hrd_py/__init__.py
+hrd_py/api.py
+hrd_py/cli.py
+hrd_py/client.py
+hrd_py/config.py
+hrd_py/exceptions.py
+hrd_py/models.py
+hrd_py.egg-info/PKG-INFO
+hrd_py.egg-info/SOURCES.txt
+hrd_py.egg-info/dependency_links.txt
+hrd_py.egg-info/entry_points.txt
+hrd_py.egg-info/requires.txt
+hrd_py.egg-info/top_level.txt
+tests/test_api.py
+tests/test_client.py

hrd_py-0.0.1/hrd_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hrd_py-0.0.1/hrd_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hrd = hrd_py.cli:cli

hrd_py-0.0.1/hrd_py.egg-info/requires.txt

@@ -0,0 +1,13 @@
+click>=8.0.0
+python-dotenv>=0.19.0
+PyYAML>=6.0
+
+[dev]
+pytest>=8.0.0
+pytest-mock>=3.14.0
+ruff>=0.3.0
+black>=24.0.0
+mypy>=1.9.0
+types-PyYAML>=6.0.0
+build>=1.0.0
+twine>=5.0.0

hrd_py-0.0.1/hrd_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+hrd_py

hrd_py-0.0.1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hrd-py"
+version = "0.0.1"
+description = "A Python library and CLI for the HRD.pl API"
+readme = "README.md"
+authors = [{name = "TheUndefined"}]
+license = {text = "MIT"}
+dependencies = [
+    "click>=8.0.0",
+    "python-dotenv>=0.19.0",
+    "PyYAML>=6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.3.0",
+    "black>=24.0.0",
+    "mypy>=1.9.0",
+    "types-PyYAML>=6.0.0",
+    "build>=1.0.0",
+    "twine>=5.0.0",
+]
+
+[project.scripts]
+hrd = "hrd_py.cli:cli"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hrd_py*"]
+
+[tool.black]
+line-length = 120
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"

hrd_py-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hrd_py-0.0.1/tests/test_api.py

@@ -0,0 +1,55 @@
+import struct
+import hashlib
+from hrd_py.api import HRDApi
+
+
+def test_api_send_receives_correct_framing(mocker):
+    # Mocking socket and ssl
+    mocker.patch("socket.create_connection")
+    mock_context = mocker.patch("ssl.create_default_context")
+    mock_ssl_sock = mock_context.return_value.wrap_socket.return_value
+
+    api = HRDApi("login", "pass", "deadbeef", verify_peer=False)
+
+    # Mock response
+    xml_response = '<api xmlns="http://api.hrd.pl/api/"><status>ok</status><token>test_token</token></api>'
+    resp_bytes = xml_response.encode("utf-8")
+    mock_ssl_sock.recv.side_effect = [struct.pack(">I", len(resp_bytes)), resp_bytes]
+
+    token = api.login()
+
+    assert token == "test_token"
+    assert api.token == "test_token"
+
+    # Verify what was sent
+    sent_data = mock_ssl_sock.sendall.call_args[0][0]
+    length = struct.unpack(">I", sent_data[:4])[0]
+    hash_sent = sent_data[4:68]
+    xml_sent = sent_data[68:].decode("utf-8")
+
+    assert length == len(sent_data) - 4
+    assert "<login>" in xml_sent
+
+    # Verify hash: SHA512(XML + binary_api_hash)
+    h = hashlib.sha512()
+    h.update(xml_sent.encode("utf-8"))
+    h.update(bytes.fromhex("deadbeef"))
+    assert h.digest() == hash_sent
+
+
+def test_partner_get_balance(mocker):
+    api = HRDApi("login", "pass", "deadbeef")
+    api.token = "test_token"
+
+    mock_request = mocker.patch.object(HRDApi, "_request")
+
+    import xml.etree.ElementTree as ET
+
+    resp_xml = "<api><partner><getBalance><balance>100.50</balance><restrictedBalance>10.00</restrictedBalance></getBalance></partner></api>"
+    mock_request.return_value = ET.fromstring(resp_xml)
+
+    balance = api.partner_get_balance()
+
+    assert balance["balance"] == 100.50
+    assert balance["restricted_balance"] == 10.00
+    mock_request.assert_called_once_with("partner", "getBalance")

hrd_py-0.0.1/tests/test_client.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from hrd_py.client import HRDClient
+from hrd_py.models import Domain
+
+
+def test_client_list_domains(mocker):
+    client = HRDClient("login", "pass", "deadbeef")
+
+    mock_api = mocker.patch.object(client, "api")
+
+    # Mock domain_list responses (pagination)
+    mock_api.domain_list.side_effect = [["domain1.pl", "domain2.pl"], []]
+
+    # Mock domain_info responses
+    mock_api.domain_info.side_effect = [
+        {"status": "registered", "exDate": "2026-06-30"},
+        {"status": "expired", "exDate": "2026-05-01"},
+    ]
+
+    domains = client.list_domains()
+
+    assert len(domains) == 2
+    assert domains[0].name == "domain1.pl"
+    assert domains[0].status == "registered"
+    assert domains[0].expiry_date == datetime(2026, 6, 30)
+    assert domains[1].name == "domain2.pl"
+    assert domains[1].status == "expired"
+
+
+def test_domain_is_expiring_soon():
+    import datetime as dt
+
+    now = datetime.now()
+
+    d_soon = Domain(name="soon.pl", status="ok", expiry_date=now + dt.timedelta(days=5))
+    d_far = Domain(name="far.pl", status="ok", expiry_date=now + dt.timedelta(days=40))
+
+    assert d_soon.is_expiring_soon() is True
+    assert d_far.is_expiring_soon() is False