heytelecom 0.1.0__py3-none-any.whl

heytelecom/__init__.py

@@ -0,0 +1,22 @@
+"""
+Hey Telecom Python Library
+
+A Python library for interacting with Hey Telecom accounts using Playwright.
+"""
+
+__version__ = "0.1.0"
+
+from .client import HeyTelecomClient
+from .models import Product, Contract, UsageData, Invoice, AccountData
+from .installer import install_playwright, ensure_playwright_installed
+
+__all__ = [
+    "HeyTelecomClient",
+    "Product",
+    "Contract",
+    "UsageData",
+    "Invoice",
+    "AccountData",
+    "install_playwright",
+    "ensure_playwright_installed",
+]

heytelecom/client.py

@@ -0,0 +1,500 @@
+"""Hey Telecom client for accessing mobile usage information."""
+import time
+from typing import Optional, Dict, Any, List
+from playwright.sync_api import sync_playwright, Browser, Page, BrowserContext
+
+from .models import Product, Contract, UsageData, Invoice, AccountData
+from .parsers import (
+    parse_data_amount, parse_price, parse_date, parse_period,
+    parse_minutes, parse_sms_count, parse_last_update, is_unlimited
+)
+
+
+class HeyTelecomClient:
+    """Client for interacting with Hey Telecom account."""
+
+    BASE_URL = "https://ecare.heytelecom.be"
+    AUTH_URL = "https://auth.heytelecom.be"
+
+    def __init__(self, email: Optional[str] = None, password: Optional[str] = None,
+                 user_data_dir: str = "hey_browser_data", auto_install: bool = True):
+        """
+        Initialize Hey Telecom client.
+
+        Args:
+            email: Email address for login (optional if already logged in)
+            password: Password for login (optional if already logged in)
+            user_data_dir: Directory to store browser session data
+            auto_install: Automatically install Playwright chromium if not found (default: True)
+        
+        Note:
+            Browser always runs in headless mode (no GUI).
+        """
+        self.email = email
+        self.password = password
+        self.user_data_dir = user_data_dir
+        self.auto_install = auto_install
+        self.headless = True  # Always run headless
+        self._playwright = None
+        self._browser: Optional[BrowserContext] = None
+        self._page: Optional[Page] = None
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+    def connect(self):
+        """Start browser and create page."""
+        # Ensure Playwright chromium is installed before connecting
+        if self.auto_install:
+            from .installer import ensure_playwright_installed
+            ensure_playwright_installed()
+        
+        self._playwright = sync_playwright().start()
+        self._browser = self._playwright.chromium.launch_persistent_context(
+            user_data_dir=self.user_data_dir,
+            headless=self.headless
+        )
+        self._page = self._browser.new_page()
+
+    def close(self):
+        """Close browser and cleanup."""
+        if self._browser:
+            self._browser.close()
+        if self._playwright:
+            self._playwright.stop()
+
+    def _handle_cookie_popup(self):
+        """Check for and handle cookie popup if present."""
+        if not self._page:
+            return False
+        
+        try:
+            reject_button = self._page.locator('button#onetrust-reject-all-handler')
+            if reject_button.count() > 0:
+                reject_button.click()
+                time.sleep(0.5)  # Reduced from 1 second
+                return True
+        except:
+            pass
+        return False
+
+    def _wait_for_page_load(self, timeout: int = 30000):
+        """Wait for page to load completely."""
+        if not self._page:
+            raise RuntimeError("Browser not connected. Call connect() first.")
+        
+        time.sleep(1)  # Minimum 1 second (reduced from 2)
+        
+        # Wait for all spinners to disappear
+        try:
+            start_time = time.time()
+            while time.time() - start_time < timeout / 1000:
+                spinners = self._page.locator('svg.p-progress-spinner')
+                if spinners.count() == 0:
+                    return True
+                time.sleep(0.2)  # Check every 200ms (reduced from 300ms)
+            return False
+        except Exception:
+            return False
+
+    def _check_logged_in(self) -> bool:
+        """Check if user is logged in."""
+        if not self._page:
+            return False
+        
+        mijn_account = self._page.locator('span.p-menuitem-text.ng-star-inserted.button-label:has-text("Mijn account")')
+        return mijn_account.count() > 0
+
+    def login(self):
+        """
+        Login to Hey Telecom account.
+        
+        Raises:
+            ValueError: If email or password not provided
+            RuntimeError: If login fails
+        """
+        if not self._page:
+            raise RuntimeError("Browser not connected. Call connect() first.")
+        
+        # Navigate to products page
+        self._page.goto(f"{self.BASE_URL}/nl/mijn-producten")
+        self._wait_for_page_load()
+        
+        # Check if already logged in (before handling cookies)
+        if self._check_logged_in():
+            return
+        
+        if not self.email or not self.password:
+            raise ValueError("Email and password required for login")
+        
+        # Wait for redirect to auth page
+        self._page.wait_for_url(f"**{self.AUTH_URL}/**", timeout=10000)
+        
+        # Click on "Inloggen via E-mail" button
+        email_login_btn = self._page.locator('a#Login_loginByEmail')
+        email_login_btn.wait_for(state="visible", timeout=10000)
+        email_login_btn.click()
+        self._wait_for_page_load()
+        
+        # Fill in email
+        email_input = self._page.locator('input#Login_byEmail_emailAddress')
+        email_input.wait_for(state="visible", timeout=10000)
+        email_input.fill(self.email)
+        
+        # Fill in password
+        password_input = self._page.locator('input#Login_byEmail_password')
+        password_input.wait_for(state="visible", timeout=10000)
+        password_input.fill(self.password)
+        
+        # Click login button
+        login_btn = self._page.locator('button#Login_byEmail_login')
+        login_btn.click()
+        self._wait_for_page_load()
+        
+        # Check for error message
+        error_msg = self._page.locator('div.error_msgs:has-text("Verkeerde gebruikersnaam en/of wachtwoord")')
+        if error_msg.count() > 0:
+            raise RuntimeError("Login failed: Wrong username and/or password")
+        
+        # Wait for successful login
+        try:
+            self._page.wait_for_selector('span.p-menuitem-text.ng-star-inserted.button-label:has-text("Mijn account")', timeout=10000)
+        except:
+            pass
+        
+        self._wait_for_page_load()
+        
+        # Verify login
+        if not self._check_logged_in():
+            raise RuntimeError("Login verification failed")
+
+    def get_products(self) -> List[Product]:
+        """
+        Get all products from the account.
+        
+        Returns:
+            List of Product objects
+        """
+        if not self._page:
+            raise RuntimeError("Browser not connected. Call connect() first.")
+        
+        # Navigate to products page
+        self._page.goto(f"{self.BASE_URL}/nl/mijn-producten")
+        self._wait_for_page_load()
+        
+        # Handle cookie popup
+        self._handle_cookie_popup()
+        time.sleep(1)
+        
+        self._page.wait_for_selector('li.iris-products__item', timeout=10000)
+        
+        products = self._page.locator('li.iris-products__item')
+        product_count = products.count()
+        
+        if product_count == 0:
+            return []
+        
+        # Collect product data
+        products_data = []
+        for i in range(product_count):
+            product = products.nth(i)
+            product_data = self._extract_product_basic_info(product)
+            identifier = self._get_product_identifier(product)
+            products_data.append({
+                "identifier": identifier,
+                "data": product_data
+            })
+        
+        # Extract usage data for each product
+        for product_info in products_data:
+            identifier = product_info["identifier"]
+            product_data = product_info["data"]
+            
+            # Find product again (in case page reloaded)
+            product = self._find_product_by_identifier(identifier)
+            if not product:
+                continue
+            
+            # Extract usage
+            consumption_link = product.locator('a.iris-products__link[data-event_category="MyProducts"]')
+            if consumption_link.count() > 0:
+                consumption_link.click()
+                usage_data = self._extract_usage_data()
+                if usage_data:
+                    product_data["usage"] = usage_data
+                
+                # Go back using browser back (faster than full page reload)
+                self._page.go_back()
+                self._wait_for_page_load()
+                self._page.wait_for_selector('li.iris-products__item', timeout=10000)
+        
+        # Convert to Product objects
+        return [self._create_product_object(p["data"]) for p in products_data]
+
+    def get_latest_invoice(self) -> Optional[Invoice]:
+        """
+        Get the latest invoice.
+        
+        Returns:
+            Invoice object or None if no invoice found
+        """
+        if not self._page:
+            raise RuntimeError("Browser not connected. Call connect() first.")
+        
+        self._page.goto(f"{self.BASE_URL}/nl/mijn-facturen")
+        self._wait_for_page_load()
+        
+        # Handle cookie popup (reduced wait time)
+        self._handle_cookie_popup()
+        time.sleep(0.5)
+        
+        try:
+            self._page.wait_for_selector('lib-obe-latest-invoice section.iris-invoice', timeout=10000)
+        except:
+            return None
+        
+        invoice_section = self._page.locator('lib-obe-latest-invoice section.iris-invoice')
+        if invoice_section.count() == 0:
+            return None
+        
+        invoice_data = {}
+        
+        # Extract amount
+        amount_element = invoice_section.locator('p.iris-invoice__main-data-title:has-text("Bedrag")').locator('xpath=following-sibling::p').first
+        if amount_element.count() > 0:
+            amount_text = amount_element.inner_text().strip()
+            invoice_data["amount_eur"] = parse_price(amount_text)
+        
+        # Extract status
+        status_element = invoice_section.locator('p.iris-invoice__main-data-title:has-text("Status")').locator('xpath=following-sibling::p').first
+        if status_element.count() > 0:
+            status_text = status_element.inner_text().strip()
+            invoice_data["status"] = status_text
+            invoice_data["paid"] = status_text.lower() == "betaald"
+        
+        # Extract date
+        date_element = invoice_section.locator('p.iris-invoice__main-data-title:has-text("Datum")').locator('xpath=following-sibling::p').first
+        if date_element.count() > 0:
+            date_text = date_element.inner_text().strip()
+            invoice_data["date"] = parse_date(date_text)
+        
+        # Extract due date
+        due_date_element = invoice_section.locator('p.iris-invoice__main-data-title:has-text("Vervaldatum")').locator('xpath=following-sibling::p').first
+        if due_date_element.count() > 0:
+            due_date_text = due_date_element.inner_text().strip()
+            invoice_data["due_date"] = parse_date(due_date_text)
+        
+        # Generate invoice ID
+        if invoice_data.get("date"):
+            invoice_data["invoice_id"] = f"INV-{invoice_data['date'].replace('-', '')}"
+        
+        return Invoice(**invoice_data)
+
+    def get_account_data(self) -> AccountData:
+        """
+        Get all account data including products and latest invoice.
+        
+        Returns:
+            AccountData object with all information
+        """
+        products = self.get_products()
+        invoice = self.get_latest_invoice()
+        
+        return AccountData(
+            products=products,
+            latest_invoice=invoice
+        )
+
+    def _extract_product_basic_info(self, product) -> Dict[str, Any]:
+        """Extract basic product information."""
+        product_data = {}
+        
+        # Phone number
+        phone_number = product.locator('span.iris-products__details-tariff-number')
+        if phone_number.count() > 0:
+            product_data["phone_number"] = phone_number.inner_text()
+        
+        # Tariff name
+        tariff_name = product.locator('span.iris-products__details-tariff-name')
+        if tariff_name.count() > 0:
+            product_data["tariff"] = tariff_name.inner_text()
+        
+        # Easy Switch number
+        easy_switch = product.locator('span.iris-products__details-info-title:has-text("Nummer Easy Switch")').locator('xpath=following-sibling::span')
+        if easy_switch.count() > 0:
+            product_data["easy_switch_number"] = easy_switch.inner_text()
+        
+        # Contract start date
+        start_date_label = product.locator('span.iris-products__details-info-title:has-text("Begindatum contract")')
+        if start_date_label.count() > 0:
+            start_date_value = start_date_label.locator('xpath=following-sibling::span').first
+            start_date_text = start_date_value.inner_text().strip()
+            if start_date_text:
+                product_data["contract_start_date"] = parse_date(start_date_text)
+        
+        # Price
+        price_label = product.locator('span.iris-products__details-info-title:has-text("Prijs")')
+        if price_label.count() > 0:
+            price_value = price_label.locator('xpath=following-sibling::span').first
+            price_text = price_value.inner_text()
+            product_data["price_per_month_eur"] = parse_price(price_text)
+        
+        return product_data
+
+    def _extract_usage_data(self) -> Optional[Dict[str, Any]]:
+        """Extract usage data from detailed usage page."""
+        try:
+            self._page.wait_for_url("**/gedetailleerd-gebruik**", timeout=10000)
+        except:
+            pass
+        
+        # Only wait for page load (selector check is redundant)
+        self._wait_for_page_load()
+        
+        if "gedetailleerd-gebruik" not in self._page.url:
+            return None
+        
+        usage_data = {}
+        
+        # Extract date range
+        date_range = self._page.locator('p.iris-consumption__main-date-range')
+        if date_range.count() > 0:
+            period_text = date_range.inner_text()
+            usage_data["period"] = parse_period(period_text)
+        
+        # Extract Data usage (mobile)
+        data_block = self._page.locator('div#consumption-data')
+        if data_block.count() > 0:
+            usage_data["data"] = self._extract_data_usage(data_block)
+        
+        # Extract Data usage (internet)
+        fix_block = self._page.locator('div#consumption-fix')
+        if fix_block.count() > 0:
+            usage_data["data"] = self._extract_data_usage(fix_block)
+        
+        # Extract Calls usage
+        calls_block = self._page.locator('div#consumption-calls')
+        if calls_block.count() > 0:
+            calls_limit = calls_block.locator('span.iris-consumption__main-data-limit')
+            calls_usage = calls_block.locator('span.iris-consumption__main-data-usage strong')
+            calls_update = calls_block.locator('span.iris-consumption__main-data-update')
+            
+            if calls_limit.count() > 0 and calls_usage.count() > 0:
+                limit_text = calls_limit.inner_text()
+                used_text = calls_usage.inner_text()
+                usage_data["calls"] = {
+                    "used": parse_minutes(used_text),
+                    "unlimited": is_unlimited(limit_text),
+                    "last_update": parse_last_update(calls_update.inner_text() if calls_update.count() > 0 else None)
+                }
+        
+        # Extract SMS/MMS usage
+        sms_block = self._page.locator('div#consumption-sms')
+        if sms_block.count() > 0:
+            sms_limit = sms_block.locator('span.iris-consumption__main-data-limit')
+            sms_usage = sms_block.locator('span.iris-consumption__main-data-usage strong')
+            sms_update = sms_block.locator('span.iris-consumption__main-data-update')
+            
+            if sms_limit.count() > 0 and sms_usage.count() > 0:
+                limit_text = sms_limit.inner_text()
+                used_text = sms_usage.inner_text()
+                usage_data["sms_mms"] = {
+                    "used": parse_sms_count(used_text),
+                    "unlimited": is_unlimited(limit_text),
+                    "last_update": parse_last_update(sms_update.inner_text() if sms_update.count() > 0 else None)
+                }
+        
+        return usage_data
+
+    def _extract_data_usage(self, block) -> Dict[str, Any]:
+        """Extract data usage from a block."""
+        data_limit = block.locator('span.iris-consumption__main-data-limit')
+        data_usage = block.locator('span.iris-consumption__main-data-usage strong')
+        data_update = block.locator('span.iris-consumption__main-data-update')
+        
+        if data_limit.count() > 0 and data_usage.count() > 0:
+            limit_text = data_limit.inner_text()
+            used_text = data_usage.inner_text()
+            return {
+                "used": parse_data_amount(used_text),
+                "limit": parse_data_amount(limit_text),
+                "unlimited": is_unlimited(limit_text),
+                "last_update": parse_last_update(data_update.inner_text() if data_update.count() > 0 else None)
+            }
+        return {}
+
+    def _get_product_identifier(self, product):
+        """Get unique identifier for a product."""
+        # Try phone number
+        phone_number = product.locator('span.iris-products__details-tariff-number')
+        if phone_number.count() > 0:
+            return ("phone", phone_number.inner_text())
+        
+        # Try Easy Switch number
+        easy_switch = product.locator('span.iris-products__details-info-title:has-text("Nummer Easy Switch")').locator('xpath=following-sibling::span')
+        if easy_switch.count() > 0:
+            return ("easy_switch", easy_switch.inner_text())
+        
+        # Fallback to tariff name
+        tariff_name = product.locator('span.iris-products__details-tariff-name')
+        if tariff_name.count() > 0:
+            return ("tariff", tariff_name.inner_text())
+        
+        return None
+
+    def _find_product_by_identifier(self, identifier):
+        """Find product by identifier."""
+        if not identifier:
+            return None
+        
+        products = self._page.locator('li.iris-products__item')
+        for i in range(products.count()):
+            product = products.nth(i)
+            current_id = self._get_product_identifier(product)
+            if current_id and current_id == identifier:
+                return product
+        
+        return None
+
+    def _create_product_object(self, data: Dict[str, Any]) -> Product:
+        """Create Product object from data dictionary."""
+        # Determine product type and ID
+        if "phone_number" in data:
+            product_type = "mobile"
+            phone_clean = data["phone_number"].replace(" ", "")
+            product_id = f"mobile_{phone_clean}"
+        elif "easy_switch_number" in data:
+            product_type = "internet"
+            product_id = f"internet_{data['easy_switch_number']}"
+        else:
+            product_type = "unknown"
+            product_id = f"unknown_{data.get('tariff', 'product')}"
+        
+        # Create contract if exists
+        contract = None
+        if "contract_start_date" in data or "price_per_month_eur" in data:
+            contract = Contract(
+                start_date=data.get("contract_start_date"),
+                price_per_month_eur=data.get("price_per_month_eur")
+            )
+        
+        # Create usage if exists
+        usage = None
+        if "usage" in data:
+            usage = UsageData(**data["usage"])
+        
+        return Product(
+            product_id=product_id,
+            product_type=product_type,
+            phone_number=data.get("phone_number"),
+            easy_switch_number=data.get("easy_switch_number"),
+            tariff=data.get("tariff"),
+            contract=contract,
+            usage=usage
+        )

heytelecom/installer.py

@@ -0,0 +1,57 @@
+"""Playwright installation utilities."""
+import subprocess
+import sys
+
+
+def install_playwright():
+    """
+    Install Playwright Chromium browser with dependencies for headless operation.
+    
+    Always installs chromium with --with-deps and --only-shell flags.
+    
+    Raises:
+        RuntimeError: If installation fails
+    """
+    cmd = ["playwright", "install", "chromium", "--with-deps", "--only-shell"]
+    
+    try:
+        print("Installing Playwright chromium...")
+        print(f"Running: {' '.join(cmd)}")
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        print(result.stdout)
+        print("Successfully installed Playwright chromium")
+    except subprocess.CalledProcessError as e:
+        print(f"Installation failed: {e.stderr}")
+        raise RuntimeError(f"Failed to install Playwright: {e}")
+    except FileNotFoundError:
+        print("Playwright command not found. Make sure playwright is installed.")
+        print("Try: pip install playwright")
+        raise RuntimeError("Playwright not found in PATH")
+
+
+def ensure_playwright_installed():
+    """
+    Check if Playwright chromium browser is installed and install if needed.
+    
+    Only installs if chromium is not already available.
+    """
+    try:
+        # Try to import playwright
+        from playwright.sync_api import sync_playwright
+        
+        # Try to launch browser to check if installed
+        try:
+            with sync_playwright() as p:
+                browser_instance = p.chromium.launch(headless=True)
+                browser_instance.close()
+            print("Playwright chromium is already installed")
+        except Exception:
+            print("Playwright chromium not found, installing...")
+            install_playwright()
+    except ImportError:
+        raise RuntimeError("Playwright package not installed. Install with: pip install playwright")
+
+
+if __name__ == "__main__":
+    """Allow running as a script for installation."""
+    install_playwright()

heytelecom/models.py

@@ -0,0 +1,132 @@
+"""Data models for Hey Telecom."""
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+
+@dataclass
+class UsageData:
+    """Represents usage data for a product."""
+    period: Optional[Dict[str, str]] = None
+    data: Optional[Dict[str, Any]] = None
+    calls: Optional[Dict[str, Any]] = None
+    sms_mms: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        result = {}
+        if self.period:
+            result["period"] = self.period
+        if self.data:
+            result["data"] = self.data
+        if self.calls:
+            result["calls"] = self.calls
+        if self.sms_mms:
+            result["sms_mms"] = self.sms_mms
+        return result
+
+
+@dataclass
+class Contract:
+    """Represents contract information."""
+    start_date: Optional[str] = None
+    price_per_month_eur: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        result = {}
+        if self.start_date:
+            result["start_date"] = self.start_date
+        if self.price_per_month_eur is not None:
+            result["price_per_month_eur"] = self.price_per_month_eur
+        return result
+
+
+@dataclass
+class Product:
+    """Represents a telecom product (mobile or internet)."""
+    product_id: str
+    product_type: str
+    phone_number: Optional[str] = None
+    easy_switch_number: Optional[str] = None
+    tariff: Optional[str] = None
+    contract: Optional[Contract] = None
+    usage: Optional[UsageData] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        result = {
+            "id": self.product_id,
+            "type": self.product_type
+        }
+        if self.phone_number:
+            result["phone_number"] = self.phone_number
+        if self.easy_switch_number:
+            result["easy_switch_number"] = self.easy_switch_number
+        if self.tariff:
+            result["tariff"] = self.tariff
+        if self.contract:
+            contract_dict = self.contract.to_dict()
+            if contract_dict:
+                result["contract"] = contract_dict
+        if self.usage:
+            usage_dict = self.usage.to_dict()
+            if usage_dict:
+                result["usage"] = usage_dict
+        return result
+
+
+@dataclass
+class Invoice:
+    """Represents an invoice."""
+    invoice_id: Optional[str] = None
+    amount_eur: Optional[float] = None
+    status: Optional[str] = None
+    paid: bool = False
+    date: Optional[str] = None
+    due_date: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        result = {}
+        if self.invoice_id:
+            result["invoice_id"] = self.invoice_id
+        if self.amount_eur is not None:
+            result["amount_eur"] = self.amount_eur
+        if self.status:
+            result["status"] = self.status.lower()
+        if self.paid is not None:
+            result["paid"] = self.paid
+        if self.date:
+            result["date"] = self.date
+        if self.due_date:
+            result["due_date"] = self.due_date
+        return result
+
+
+@dataclass
+class AccountData:
+    """Represents account-level data."""
+    provider: str = "hey!"
+    last_sync: Optional[str] = None
+    products: list[Product] = field(default_factory=list)
+    latest_invoice: Optional[Invoice] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format."""
+        result = {
+            "provider": self.provider,
+            "account": {
+                "last_sync": self.last_sync or datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+            },
+            "products": [product.to_dict() for product in self.products]
+        }
+        
+        if self.latest_invoice:
+            invoice_dict = self.latest_invoice.to_dict()
+            if invoice_dict:
+                result["billing"] = {
+                    "latest_invoice": invoice_dict
+                }
+        
+        return result

heytelecom/parsers.py

@@ -0,0 +1,101 @@
+"""Parsing utilities for Hey Telecom data."""
+import re
+from datetime import datetime
+
+
+def parse_data_amount(text):
+    """Parse data amount like '2.25 GB' to numeric GB value."""
+    if not text:
+        return None
+    match = re.search(r'([\d.]+)\s*(GB|MB|TB)', text, re.IGNORECASE)
+    if match:
+        value = float(match.group(1))
+        unit = match.group(2).upper()
+        if unit == 'MB':
+            value = value / 1024  # Convert to GB
+        elif unit == 'TB':
+            value = value * 1024  # Convert to GB
+        return round(value, 2)
+    return None
+
+
+def parse_price(text):
+    """Parse price like '5 €/maand' to numeric value."""
+    if not text:
+        return None
+    match = re.search(r'([\d.]+)\s*€', text)
+    if match:
+        return float(match.group(1))
+    return None
+
+
+def parse_date(text):
+    """Parse date like '04.04.2025' or '20/10/2025' to ISO format."""
+    if not text:
+        return None
+    # Try DD.MM.YYYY format
+    match = re.search(r'(\d{2})\.(\d{2})\.(\d{4})', text)
+    if match:
+        day, month, year = match.groups()
+        return f"{year}-{month}-{day}"
+    # Try DD/MM/YYYY format
+    match = re.search(r'(\d{2})/(\d{2})/(\d{4})', text)
+    if match:
+        day, month, year = match.groups()
+        return f"{year}-{month}-{day}"
+    return None
+
+
+def parse_period(text):
+    """Parse period like 'Van 11/10/2025 tot 11/11/2025' to start and end dates."""
+    if not text:
+        return None
+    match = re.search(r'(\d{2}/\d{2}/\d{4})\s*tot\s*(\d{2}/\d{2}/\d{4})', text)
+    if match:
+        start_str, end_str = match.groups()
+        return {
+            "start": parse_date(start_str),
+            "end": parse_date(end_str)
+        }
+    return None
+
+
+def parse_minutes(text):
+    """Parse minutes like '5 minuten' to numeric value."""
+    if not text:
+        return None
+    match = re.search(r'([\d.]+)\s*min', text, re.IGNORECASE)
+    if match:
+        return float(match.group(1))
+    return None
+
+
+def parse_sms_count(text):
+    """Parse SMS count like '0 sms/mms' to numeric value."""
+    if not text:
+        return None
+    match = re.search(r'([\d.]+)\s*sms', text, re.IGNORECASE)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def parse_last_update(text):
+    """Parse last update like 'Laatste update : 03/11 17:54' to ISO datetime."""
+    if not text:
+        return None
+    match = re.search(r'(\d{2}/\d{2})\s*(\d{2}:\d{2})', text)
+    if match:
+        date_part, time_part = match.groups()
+        day, month = date_part.split('/')
+        # Assume current year
+        year = datetime.now().year
+        return f"{year}-{month}-{day}T{time_part}:00"
+    return None
+
+
+def is_unlimited(text):
+    """Check if a limit is unlimited."""
+    if not text:
+        return False
+    return 'onbeperkt' in text.lower() or 'unlimited' in text.lower()

heytelecom-0.1.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.4
+Name: heytelecom
+Version: 0.1.0
+Summary: A Python library for interacting with Hey Telecom accounts
+Author-email: CoderMauro <mauro.druwel@gmail.com>
+Project-URL: Homepage, https://github.com/maurodruwel/heytelecom
+Project-URL: Repository, https://github.com/maurodruwel/heytelecom
+Keywords: hey,telecom,hey!,belgium,mobile,internet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# HeyTelecom Python Library
+
+<img width="1280" height="668" alt="HeyTelecom Banner" src="https://github.com/user-attachments/assets/d141fb44-e5c3-48af-a2b0-42ba4d2c510f" />
+
+<p align="center">
+  <img alt="PyPI" src="https://img.shields.io/pypi/v/heytelecom"/>
+  <img alt="Python Version" src="https://img.shields.io/pypi/pyversions/heytelecom"/>
+  <img alt="License" src="https://img.shields.io/github/license/MauroDruwel/HeyTelecom"/>
+  <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/MauroDruwel/HeyTelecom"/>
+  <img alt="GitHub last commit" src="https://img.shields.io/github/last-commit/MauroDruwel/HeyTelecom"/>
+</p>
+
+<p align="center">
+  <a href="#installation">Installation</a> -
+  <a href="#quick-start">Quick Start</a> -
+  <a href="#features">Features</a> -
+  <a href="#api-reference">API Reference</a> -
+  <a href="https://github.com/MauroDruwel/HeyTelecom/issues">Bug Reports</a>
+</p>
+
+A Python library for interacting with [Hey Telecom](https://ecare.heytelecom.be) (hey!) accounts using Playwright for web automation. Automatically extract your mobile/internet usage, invoices, and account information.
+
+## Features
+
+- 🔐 Automatic login with session persistence
+- 📱 Retrieve mobile and internet product information
+- 📊 Get usage data (data, calls, SMS/MMS)
+- 💰 Fetch invoice information
+- 🎭 Built on Playwright for reliable web automation (headless only)
+- 🔧 Object-oriented API for easy integration
+- 🚀 Chromium browser with automatic dependency installation
+
+## Installation
+
+```bash
+pip install heytelecom
+```
+
+## Quick Start
+
+```python
+from heytelecom import HeyTelecomClient
+
+with HeyTelecomClient(email="your@email.com", password="your_password") as client:
+    client.login()
+    account_data = client.get_account_data()
+    
+    import json
+    print(json.dumps(account_data.to_dict(), indent=2))
+```
+
+## API Reference
+
+### HeyTelecomClient
+
+Main client class for interacting with Hey Telecom.
+
+#### Constructor
+
+```python
+HeyTelecomClient(
+    email: Optional[str] = None,
+    password: Optional[str] = None,
+    user_data_dir: str = "hey_browser_data",
+    auto_install: bool = True
+)
+```
+
+**Parameters:**
+- `email`: Email address for login (optional if using saved session)
+- `password`: Password for login (optional if using saved session)
+- `user_data_dir`: Directory to store browser session data (default: "hey_browser_data")
+- `auto_install`: Automatically install Playwright chromium if not found (default: True)
+
+**Note:** Browser always runs in headless mode (no GUI) for reliable automation.
+
+**Auto-Installation:**
+When `auto_install=True` (default), the client automatically checks if Playwright chromium is installed when connecting. The check works by attempting to launch chromium - if it fails, the installer runs `playwright install chromium --with-deps --only-shell`. Set `auto_install=False` to disable this behavior and handle installation manually.
+
+#### Methods
+
+- `login()`: Login to Hey Telecom account
+- `get_products()`: Get list of all products (mobile and internet)
+- `get_latest_invoice()`: Get the latest invoice
+- `get_account_data()`: Get complete account data including products and invoice
+
+### Data Models
+
+#### Product
+- `product_id`: Unique product identifier
+- `product_type`: Type of product ("mobile" or "internet")
+- `phone_number`: Phone number (for mobile products)
+- `easy_switch_number`: Easy Switch number (for internet products)
+- `tariff`: Tariff/plan name
+- `contract`: Contract information (Contract object)
+- `usage`: Usage data (UsageData object)
+
+#### Contract
+- `start_date`: Contract start date (ISO format)
+- `price_per_month_eur`: Monthly price in EUR
+
+#### UsageData
+- `period`: Billing period with start and end dates
+- `data`: Data usage information (used, limit, unlimited)
+- `calls`: Call usage information (used, unlimited)
+- `sms_mms`: SMS/MMS usage information (used, unlimited)
+
+#### Invoice
+- `invoice_id`: Invoice identifier
+- `amount_eur`: Invoice amount in EUR
+- `status`: Invoice status
+- `paid`: Whether invoice is paid (boolean)
+- `date`: Invoice date (ISO format)
+- `due_date`: Invoice due date (ISO format)
+
+#### AccountData
+- `provider`: Provider name (always "hey!")
+- `last_sync`: Last synchronization timestamp
+- `products`: List of Product objects
+- `latest_invoice`: Latest Invoice object
+
+## Example Output
+
+```json
+{
+  "provider": "hey!",
+  "account": {
+    "last_sync": "2025-11-09T15:30:00"
+  },
+  "products": [
+    {
+      "id": "mobile_0412345678",
+      "type": "mobile",
+      "phone_number": "0412 34 56 78",
+      "tariff": "Hey! Mobile Plus",
+      "contract": {
+        "start_date": "2024-01-15",
+        "price_per_month_eur": 15.0
+      },
+      "usage": {
+        "period": {
+          "start": "2025-10-11",
+          "end": "2025-11-11"
+        },
+        "data": {
+          "used": 2.5,
+          "limit": 10.0,
+          "unlimited": false,
+          "last_update": "2025-11-09T14:30:00"
+        },
+        "calls": {
+          "used": 45.0,
+          "unlimited": true,
+          "last_update": "2025-11-09T14:30:00"
+        },
+        "sms_mms": {
+          "used": 12,
+          "unlimited": true,
+          "last_update": "2025-11-09T14:30:00"
+        }
+      }
+    }
+  ],
+  "billing": {
+    "latest_invoice": {
+      "invoice_id": "INV-20251101",
+      "amount_eur": 15.0,
+      "status": "betaald",
+      "paid": true,
+      "date": "2025-11-01",
+      "due_date": "2025-11-15"
+    }
+  }
+}
+```
+
+## Project Structure
+
+```
+heytestdev/
+├── src/
+│   └── heytelecom/
+│       ├── __init__.py          # Package initialization and exports
+│       ├── client.py            # Main HeyTelecomClient class
+│       ├── models.py            # Data models (Product, Invoice, etc.)
+│       ├── parsers.py           # Parsing utilities
+│       └── installer.py         # Playwright installation utilities
+├── README.md                    # This file
+├── pyproject.toml              # Package configuration
+└── .gitignore                  # Git ignore rules
+```
+
+## Requirements
+
+- Python 3.8+
+- playwright
+
+## Advanced Usage
+
+### Using Saved Sessions
+
+After the first login, the browser session is saved. You can use the library without credentials:
+
+```python
+from heytelecom import HeyTelecomClient
+
+with HeyTelecomClient() as client:
+    account_data = client.get_account_data()
+    print(f"Found {len(account_data.products)} products")
+```
+
+### Getting Specific Data
+
+```python
+from heytelecom import HeyTelecomClient
+
+with HeyTelecomClient() as client:
+    # Get only products
+    products = client.get_products()
+    for product in products:
+        print(f"Product: {product.tariff}")
+        print(f"Type: {product.product_type}")
+        if product.usage:
+            print(f"Usage: {product.usage.to_dict()}")
+    
+    # Get only latest invoice
+    invoice = client.get_latest_invoice()
+    if invoice:
+        print(f"Invoice: {invoice.amount_eur} EUR")
+        print(f"Status: {invoice.status}")
+        print(f"Paid: {invoice.paid}")
+```
+
+### Manual Playwright Installation
+
+Playwright chromium is automatically installed on first use. If you prefer manual installation:
+
+```bash
+# Manual installation (optional)
+playwright install chromium --with-deps --only-shell
+```
+
+Or use the built-in installer:
+
+```python
+from heytelecom import ensure_playwright_installed
+ensure_playwright_installed()
+```
+
+### Disabling Auto-Installation
+
+If you prefer to handle Playwright installation manually:
+
+```python
+from heytelecom import HeyTelecomClient
+
+with HeyTelecomClient(auto_install=False) as client:
+    account_data = client.get_account_data()
+    print(account_data.to_dict())
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License
+
+## Support
+
+For issues and questions, please open an issue on the GitHub repository.

heytelecom-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+heytelecom/__init__.py,sha256=TjZMEikcnt3dvPbi01mEJI9aIP4Dc75anvjv1-obU0I,498
+heytelecom/client.py,sha256=TJFECovbdwM5p-6B7NVMszUslbjWhrB0bTmELGoOuw4,19978
+heytelecom/installer.py,sha256=RcfcoDjm5xpTZxR7RYkHXCDwGaMMJRUvPZgDHbfuoj8,2004
+heytelecom/models.py,sha256=x5LtT_Vrzm_QXVw77WAwlpfVUFkX085ekrIwZ-a8zqM,4125
+heytelecom/parsers.py,sha256=0BHxLwB3xiETmKv_DDf7VmY4OGsWK1PMKNhGwNMsE_k,2858
+heytelecom-0.1.0.dist-info/licenses/LICENSE,sha256=tBT_MoFfp4ubN-UVljOcouWni-9sAh_lEpaUBK3_Fg4,1069
+heytelecom-0.1.0.dist-info/METADATA,sha256=zSB_iIPL7YzBQJKRMvgZ_xL8KwJ4OFEX9TC6slIbXzI,9068
+heytelecom-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+heytelecom-0.1.0.dist-info/entry_points.txt,sha256=E8fXx94HXplLQus2KthwqUC-f6-SqWjzYJDfznLp0i4,65
+heytelecom-0.1.0.dist-info/top_level.txt,sha256=478u-02JpuoYZjP0Gg6wbKoxPt8TG8ZiE0c_uMGp2sY,11
+heytelecom-0.1.0.dist-info/RECORD,,

heytelecom-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

heytelecom-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+heytelecom-install = heytelecom.installer:main

heytelecom-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mauro Druwel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

heytelecom-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+heytelecom