tplink-deco-api 0.1.0__py3-none-any.whl

tplink_deco/__init__.py

@@ -0,0 +1,39 @@
+from .client import DecoClient
+from .exceptions import ApiError, AuthenticationError, CryptoError, DecoError, TransportError
+from .models import (
+    ClientDevice,
+    Device,
+    DeviceMode,
+    IotHost,
+    LoginResult,
+    MloHost,
+    Performance,
+    SignalLevel,
+    WlanBackhaul,
+    WlanBand,
+    WlanConfig,
+    WlanGuest,
+    WlanHost,
+)
+
+__all__ = [
+    "DecoClient",
+    "DecoError",
+    "AuthenticationError",
+    "ApiError",
+    "CryptoError",
+    "TransportError",
+    "LoginResult",
+    "Device",
+    "SignalLevel",
+    "DeviceMode",
+    "WlanConfig",
+    "WlanBand",
+    "WlanHost",
+    "WlanGuest",
+    "WlanBackhaul",
+    "IotHost",
+    "MloHost",
+    "Performance",
+    "ClientDevice",
+]

tplink_deco/auth/__init__.py

@@ -0,0 +1,5 @@
+from .protocol import build_payload, parse_plain_response, parse_response
+from .session import SessionContext
+from .transport import HttpTransport
+
+__all__ = ["SessionContext", "HttpTransport", "build_payload", "parse_response", "parse_plain_response"]

tplink_deco/auth/protocol.py

@@ -0,0 +1,45 @@
+import json
+from typing import Any
+from urllib.parse import quote_plus
+
+from ..crypto.aes import aes_decrypt, aes_encrypt
+from ..crypto.rsa import rsa_encrypt
+from ..exceptions.api import ApiError
+from ..models.rsa_key import RsaKey
+from ..models.session_keys import SessionKeys
+
+
+def build_payload(keys: SessionKeys, sign_key: RsaKey, data: dict[str, Any]) -> str:
+    data_b64 = _encode_data(keys, data)
+    sign     = _encode_sign(keys, sign_key, len(data_b64))
+    return f"sign={sign}&data={quote_plus(data_b64)}"
+
+
+def parse_response(raw: dict[str, Any], keys: SessionKeys) -> dict[str, Any]:
+    data_b64 = raw.get("data", "")
+    if not data_b64:
+        raise ApiError(-1)
+    decrypted = json.loads(aes_decrypt(keys.aes_key, keys.aes_iv, data_b64))
+    _check_error(decrypted)
+    return decrypted.get("result", {})
+
+
+def parse_plain_response(raw: dict[str, Any]) -> dict[str, Any]:
+    _check_error(raw)
+    return raw.get("result", {})
+
+
+def _encode_data(keys: SessionKeys, data: dict[str, Any]) -> str:
+    return aes_encrypt(keys.aes_key, keys.aes_iv, json.dumps(data, separators=(",", ":")))
+
+
+def _encode_sign(keys: SessionKeys, sign_key: RsaKey, data_len: int) -> str:
+    seq_with_len = keys.seq + data_len
+    sig_str = f"k={keys.aes_key}&i={keys.aes_iv}&h={keys.session_hash}&s={seq_with_len}"
+    return rsa_encrypt(sign_key.n, sign_key.e, sig_str.encode())
+
+
+def _check_error(response: dict[str, Any]) -> None:
+    code = response.get("error_code") or response.get("errorcode")
+    if code and code != 0:
+        raise ApiError(int(code))

tplink_deco/auth/session.py

@@ -0,0 +1,26 @@
+from ..models.rsa_key import RsaKey
+from ..models.session_keys import SessionKeys
+
+
+class SessionContext:
+    def __init__(
+        self,
+        sign_key: RsaKey,
+        pwd_key:  RsaKey,
+        keys:     SessionKeys,
+        stok:     str = "",
+    ):
+        self.sign_key = sign_key
+        self.pwd_key  = pwd_key
+        self.keys     = keys
+        self.stok     = stok
+
+    def is_authenticated(self) -> bool:
+        return bool(self.stok)
+
+    def increment_seq(self) -> None:
+        self.keys.seq += 1
+
+    def invalidate(self) -> None:
+        self.stok     = ""
+        self.keys.seq = 0

tplink_deco/auth/transport.py

@@ -0,0 +1,43 @@
+import json
+import re
+import urllib.error
+import urllib.request
+from typing import Any
+
+from ..exceptions.transport import TransportError
+
+_COOKIE_RE = re.compile(r"(sysauth=[a-f0-9]+)")
+
+
+class HttpTransport:
+    def __init__(self, timeout: float = 10.0):
+        self.timeout = timeout
+        self._cookie: str | None = None
+
+    def post_json(self, url: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._post(url, json.dumps(body).encode())
+
+    def post_form(self, url: str, body: str) -> dict[str, Any]:
+        return self._post(url, body.encode())
+
+    def _post(self, url: str, data: bytes) -> dict[str, Any]:
+        headers = {"Content-Type": "application/json"}
+        if self._cookie:
+            headers["Cookie"] = self._cookie
+        req = urllib.request.Request(url, data=data, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                self._capture_cookie(resp)
+                return json.loads(resp.read())
+        except urllib.error.HTTPError as exc:
+            raise TransportError(str(exc), status_code=exc.code) from exc
+        except urllib.error.URLError as exc:
+            raise TransportError(str(exc)) from exc
+
+    def _capture_cookie(self, resp) -> None:
+        for header, value in resp.headers.items():
+            if header.lower() == "set-cookie":
+                match = _COOKIE_RE.search(value)
+                if match:
+                    self._cookie = match.group(1)
+                    break

tplink_deco/client.py

@@ -0,0 +1,120 @@
+from typing import Any
+
+from . import endpoints
+from .auth.protocol import build_payload, parse_response
+from .auth.session import SessionContext
+from .auth.transport import HttpTransport
+from .crypto import generate_aes_pair, md5_session_hash, rsa_encrypt
+from .exceptions import AuthenticationError
+from .models import (
+    ClientDevice,
+    Device,
+    DeviceMode,
+    LoginResult,
+    Performance,
+    RsaKey,
+    SessionKeys,
+    WlanConfig,
+)
+
+
+class DecoClient:
+    def __init__(
+        self,
+        host:     str,
+        username: str,
+        password: str,
+        timeout:  float = 10.0,
+    ):
+        self._host      = host
+        self._username  = username
+        self._password  = password
+        self._transport = HttpTransport(timeout=timeout)
+        self._session:  SessionContext | None = None
+
+    def __enter__(self) -> "DecoClient":
+        self.login()
+        return self
+
+    def __exit__(self, *_) -> None:
+        self.logout()
+
+    def login(self) -> LoginResult:
+        auth_raw = self._transport.post_json(
+            endpoints.login_url(self._host, "auth"),
+            {"operation": "read"},
+        )
+        keys_raw = self._transport.post_json(
+            endpoints.login_url(self._host, "keys"),
+            {"operation": "read"},
+        )
+
+        sign_key = RsaKey.from_hex(*auth_raw["result"]["key"])
+        pwd_key  = RsaKey.from_hex(*keys_raw["result"]["password"])
+        seq      = auth_raw["result"]["seq"]
+
+        aes_key, aes_iv  = generate_aes_pair()
+        session_hash     = md5_session_hash(self._username, self._password)
+        keys = SessionKeys(aes_key=aes_key, aes_iv=aes_iv,
+                           session_hash=session_hash, seq=seq)
+
+        self._session = SessionContext(sign_key=sign_key, pwd_key=pwd_key, keys=keys)
+
+        password_encrypted = rsa_encrypt(
+            pwd_key.n, pwd_key.e, self._password.encode()
+        )
+        login_body = build_payload(
+            keys, sign_key,
+            {"operation": "login", "params": {"password": password_encrypted}},
+        )
+        raw = self._transport.post_form(
+            endpoints.login_url(self._host, "login"), login_body
+        )
+
+        result = parse_response(raw, keys)
+        if "stok" not in result:
+            raise AuthenticationError("Login falhou — stok ausente na resposta")
+
+        self._session.stok = result["stok"]
+        return LoginResult(stok=result["stok"], usr_lvl=result.get("usrLvl", 1))
+
+    def logout(self) -> None:
+        if self._session:
+            self._session.invalidate()
+
+    def is_authenticated(self) -> bool:
+        return self._session is not None and self._session.is_authenticated()
+
+    def request(self, path: str, form: str, data: dict[str, Any]) -> dict[str, Any]:
+        self._require_auth()
+        url  = endpoints.admin_url(self._host, self._session.stok, path, form)
+        body = build_payload(self._session.keys, self._session.sign_key, data)
+        raw  = self._transport.post_form(url, body)
+        return parse_response(raw, self._session.keys)
+
+    def get_device_list(self) -> list[Device]:
+        result = self.request("admin/device", "device_list", {"operation": "read"})
+        return [Device.from_api(d) for d in result.get("device_list", [])]
+
+    def get_device_mode(self) -> DeviceMode:
+        result = self.request("admin/device", "mode", {"operation": "read"})
+        return DeviceMode.from_api(result)
+
+    def get_wlan_config(self) -> WlanConfig:
+        result = self.request("admin/wireless", "wlan", {"operation": "read"})
+        return WlanConfig.from_api(result)
+
+    def get_performance(self) -> Performance:
+        result = self.request("admin/network", "performance", {"operation": "read"})
+        return Performance.from_api(result)
+
+    def get_client_list(self, deco_mac: str = "default") -> list[ClientDevice]:
+        result = self.request(
+            "admin/client", "client_list",
+            {"operation": "read", "params": {"device_mac": deco_mac}},
+        )
+        return [ClientDevice.from_api(c) for c in result.get("client_list", [])]
+
+    def _require_auth(self) -> None:
+        if not self.is_authenticated():
+            raise AuthenticationError("Não autenticado — chame login() primeiro")

tplink_deco/crypto/__init__.py

@@ -0,0 +1,5 @@
+from .aes import aes_decrypt, aes_encrypt, generate_aes_pair
+from .hash import md5_session_hash
+from .rsa import rsa_encrypt
+
+__all__ = ["generate_aes_pair", "aes_encrypt", "aes_decrypt", "rsa_encrypt", "md5_session_hash"]

tplink_deco/crypto/aes.py

@@ -0,0 +1,37 @@
+import secrets
+from base64 import b64decode, b64encode
+
+from cryptography.hazmat.primitives import padding as sym_padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+from ..exceptions.crypto import CryptoError
+
+_KEY_DIGITS = 16
+_KEY_MIN    = 10 ** (_KEY_DIGITS - 1)
+_KEY_MAX    = (10 ** _KEY_DIGITS) - 1
+
+
+def generate_aes_pair() -> tuple[str, str]:
+    key = str(secrets.randbelow(_KEY_MAX - _KEY_MIN) + _KEY_MIN)
+    iv  = str(secrets.randbelow(_KEY_MAX - _KEY_MIN) + _KEY_MIN)
+    return key, iv
+
+
+def aes_encrypt(key: str, iv: str, plaintext: str) -> str:
+    padder = sym_padding.PKCS7(128).padder()
+    padded = padder.update(plaintext.encode()) + padder.finalize()
+    cipher = Cipher(algorithms.AES(key.encode()), modes.CBC(iv.encode()))
+    enc    = cipher.encryptor()
+    return b64encode(enc.update(padded) + enc.finalize()).decode()
+
+
+def aes_decrypt(key: str, iv: str, ciphertext_b64: str) -> str:
+    try:
+        ct     = b64decode(ciphertext_b64)
+        cipher = Cipher(algorithms.AES(key.encode()), modes.CBC(iv.encode()))
+        dec    = cipher.decryptor()
+        raw    = dec.update(ct) + dec.finalize()
+        n_pad  = raw[-1]
+        return raw[:-n_pad].decode()
+    except Exception as exc:
+        raise CryptoError(f"Falha ao decifrar AES: {exc}") from exc

tplink_deco/crypto/hash.py

@@ -0,0 +1,5 @@
+import hashlib
+
+
+def md5_session_hash(username: str, password: str) -> str:
+    return hashlib.md5((username + password).encode()).hexdigest()

tplink_deco/crypto/rsa.py

@@ -0,0 +1,27 @@
+import math
+import secrets
+
+from ..exceptions.crypto import CryptoError
+
+
+def rsa_encrypt(n: int, e: int, plaintext: bytes) -> str:
+    block_size      = (int(math.log2(n)) + 8) >> 3
+    bytes_per_block = block_size - 11
+    result = ""
+    for i in range(0, len(plaintext), bytes_per_block):
+        result += _encrypt_block(n, e, block_size, plaintext[i : i + bytes_per_block])
+    return result
+
+
+def _encrypt_block(n: int, e: int, k: int, block: bytes) -> str:
+    if len(block) > k - 11:
+        raise CryptoError(f"Bloco RSA muito longo: {len(block)} > {k - 11}")
+    pad_len = k - len(block) - 3
+    pad = b""
+    while len(pad) < pad_len:
+        byte = secrets.token_bytes(1)
+        if byte != b"\x00":
+            pad += byte
+    em = b"\x00\x02" + pad + b"\x00" + block
+    ct = pow(int.from_bytes(em, "big"), e, n)
+    return format(ct, f"0{k * 2}x")

tplink_deco/endpoints.py

@@ -0,0 +1,24 @@
+_PLAIN_ENDPOINTS: frozenset[str] = frozenset({
+    "/login?form=auth",
+    "/login?form=keys",
+    "/login?form=check_factory_default",
+    "/login?form=default_info",
+    "/admin/system?form=envar",
+    "/admin/system?form=sysmode",
+    "/admin/cloud?form=firmware",
+    "/admin/isp?form=isp_upgrade",
+    "/admin/firmware?form=config_multipart",
+    "/admin/log_export?form=save_log",
+})
+
+
+def is_plain(path_with_form: str) -> bool:
+    return path_with_form in _PLAIN_ENDPOINTS
+
+
+def login_url(host: str, form: str) -> str:
+    return f"http://{host}/cgi-bin/luci/;stok=/login?form={form}"
+
+
+def admin_url(host: str, stok: str, path: str, form: str) -> str:
+    return f"http://{host}/cgi-bin/luci/;stok={stok}/{path}?form={form}"

tplink_deco/exceptions/__init__.py

@@ -0,0 +1,7 @@
+from .api import ApiError
+from .auth import AuthenticationError
+from .base import DecoError
+from .crypto import CryptoError
+from .transport import TransportError
+
+__all__ = ["DecoError", "AuthenticationError", "ApiError", "CryptoError", "TransportError"]

tplink_deco/exceptions/api.py

@@ -0,0 +1,7 @@
+from .base import DecoError
+
+
+class ApiError(DecoError):
+    def __init__(self, error_code: int):
+        super().__init__(f"API returned error_code={error_code}")
+        self.error_code = error_code

tplink_deco/exceptions/auth.py

@@ -0,0 +1,5 @@
+from .base import DecoError
+
+
+class AuthenticationError(DecoError):
+    pass

tplink_deco/exceptions/base.py

@@ -0,0 +1,2 @@
+class DecoError(Exception):
+    pass

tplink_deco/exceptions/crypto.py

@@ -0,0 +1,5 @@
+from .base import DecoError
+
+
+class CryptoError(DecoError):
+    pass

tplink_deco/exceptions/transport.py

@@ -0,0 +1,7 @@
+from .base import DecoError
+
+
+class TransportError(DecoError):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code

tplink_deco/models/__init__.py

@@ -0,0 +1,35 @@
+from .client_device import ClientDevice
+from .device import Device
+from .device_mode import DeviceMode
+from .login_result import LoginResult
+from .performance import Performance
+from .rsa_key import RsaKey
+from .session_keys import SessionKeys
+from .signal_level import SignalLevel
+from .wlan_config import (
+    IotHost,
+    MloHost,
+    WlanBackhaul,
+    WlanBand,
+    WlanConfig,
+    WlanGuest,
+    WlanHost,
+)
+
+__all__ = [
+    "RsaKey",
+    "SessionKeys",
+    "LoginResult",
+    "Device",
+    "SignalLevel",
+    "DeviceMode",
+    "WlanConfig",
+    "WlanBand",
+    "WlanHost",
+    "WlanGuest",
+    "WlanBackhaul",
+    "IotHost",
+    "MloHost",
+    "Performance",
+    "ClientDevice",
+]

tplink_deco/models/_utils.py

@@ -0,0 +1,11 @@
+from base64 import b64decode
+
+
+def decode_b64(value: str) -> str:
+    if not value:
+        return value
+    return b64decode(value).decode()
+
+
+def normalize_mac(value: str) -> str:
+    return value.replace("-", ":").upper()

tplink_deco/models/client_device.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ._utils import decode_b64, normalize_mac
+
+
+@dataclass(frozen=True)
+class ClientDevice:
+    mac: str
+    ip: str
+    name: str
+    up_speed: int
+    down_speed: int
+    wire_type: str
+    connection_type: str
+    space_id: str
+    access_host: str
+    interface: str
+    client_type: str
+    owner_id: str
+    remain_time: int
+    online: bool
+    client_mesh: bool
+    enable_priority: bool
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "ClientDevice":
+        return cls(
+            mac=normalize_mac(data["mac"]),
+            ip=data.get("ip", ""),
+            name=decode_b64(data.get("name", "")),
+            up_speed=int(data.get("up_speed", 0)),
+            down_speed=int(data.get("down_speed", 0)),
+            wire_type=data.get("wire_type", ""),
+            connection_type=data.get("connection_type", ""),
+            space_id=data.get("space_id", ""),
+            access_host=data.get("access_host", ""),
+            interface=data.get("interface", ""),
+            client_type=data.get("client_type", ""),
+            owner_id=data.get("owner_id", ""),
+            remain_time=int(data.get("remain_time", 0)),
+            online=bool(data.get("online", False)),
+            client_mesh=bool(data.get("client_mesh", False)),
+            enable_priority=bool(data.get("enable_priority", False)),
+        )

tplink_deco/models/device.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ._utils import decode_b64, normalize_mac
+from .signal_level import SignalLevel
+
+
+@dataclass(frozen=True)
+class Device:
+    mac: str
+    device_ip: str
+    device_model: str
+    device_type: str
+    role: str
+    nickname: str
+    custom_nickname: str
+    hardware_ver: str
+    software_ver: str
+    oem_id: str
+    hw_id: str
+    bssid_2g: str
+    bssid_5g: str
+    bssid_sta_2g: str
+    bssid_sta_5g: str
+    inet_status: str
+    inet_error_msg: str
+    group_status: str
+    signal_level: SignalLevel
+    product_level: int
+    set_gateway_support: bool
+    support_plc: bool
+    oversized_firmware: bool
+    nand_flash: bool
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "Device":
+        return cls(
+            mac=normalize_mac(data["mac"]),
+            device_ip=data.get("device_ip", ""),
+            device_model=data.get("device_model", ""),
+            device_type=data.get("device_type", ""),
+            role=data.get("role", ""),
+            nickname=data.get("nickname", ""),
+            custom_nickname=decode_b64(data.get("custom_nickname", "")),
+            hardware_ver=data.get("hardware_ver", ""),
+            software_ver=data.get("software_ver", ""),
+            oem_id=data.get("oem_id", ""),
+            hw_id=data.get("hw_id", ""),
+            bssid_2g=normalize_mac(data.get("bssid_2g", "")),
+            bssid_5g=normalize_mac(data.get("bssid_5g", "")),
+            bssid_sta_2g=normalize_mac(data.get("bssid_sta_2g", "")),
+            bssid_sta_5g=normalize_mac(data.get("bssid_sta_5g", "")),
+            inet_status=data.get("inet_status", ""),
+            inet_error_msg=data.get("inet_error_msg", ""),
+            group_status=data.get("group_status", ""),
+            signal_level=SignalLevel.from_api(data.get("signal_level", {})),
+            product_level=int(data.get("product_level", 0)),
+            set_gateway_support=bool(data.get("set_gateway_support", False)),
+            support_plc=bool(data.get("support_plc", False)),
+            oversized_firmware=bool(data.get("oversized_firmware", False)),
+            nand_flash=bool(data.get("nand_flash", False)),
+        )

tplink_deco/models/device_mode.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class DeviceMode:
+    workmode: str
+    sysmode: str
+    region: str = ""
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "DeviceMode":
+        return cls(
+            workmode=data.get("workmode", ""),
+            sysmode=data.get("sysmode", ""),
+            region=data.get("region", {}).get("device", ""),
+        )

tplink_deco/models/login_result.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class LoginResult:
+    stok:    str
+    usr_lvl: int = 1

tplink_deco/models/performance.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Performance:
+    cpu_usage: float
+    mem_usage: float
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "Performance":
+        return cls(
+            cpu_usage=float(data["cpu_usage"]),
+            mem_usage=float(data["mem_usage"]),
+        )

tplink_deco/models/rsa_key.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RsaKey:
+    n: int
+    e: int
+
+    @classmethod
+    def from_hex(cls, modulus_hex: str, exponent_hex: str) -> "RsaKey":
+        return cls(n=int(modulus_hex, 16), e=int(exponent_hex, 16))

tplink_deco/models/session_keys.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class SessionKeys:
+    aes_key:      str
+    aes_iv:       str
+    session_hash: str
+    seq:          int

tplink_deco/models/signal_level.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SignalLevel:
+    band2_4: str
+    band5: str
+    band6: str
+
+    @classmethod
+    def from_api(cls, data: dict[str, str]) -> "SignalLevel":
+        return cls(
+            band2_4=data.get("band2_4", "0"),
+            band5=data.get("band5", "0"),
+            band6=data.get("band6", "0"),
+        )

tplink_deco/models/wlan_config.py

@@ -0,0 +1,131 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ._utils import decode_b64
+
+
+@dataclass(frozen=True)
+class WlanHost:
+    ssid: str
+    password: str
+    channel: int
+    enable: bool
+    mode: str
+    channel_width: str
+    enable_hide_ssid: bool
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "WlanHost":
+        return cls(
+            ssid=decode_b64(data.get("ssid", "")),
+            password=decode_b64(data.get("password", "")),
+            channel=int(data.get("channel", 0)),
+            enable=bool(data.get("enable", False)),
+            mode=data.get("mode", ""),
+            channel_width=data.get("channel_width", ""),
+            enable_hide_ssid=bool(data.get("enable_hide_ssid", False)),
+        )
+
+
+@dataclass(frozen=True)
+class WlanGuest:
+    ssid: str
+    password: str
+    enable: bool
+    vlan_id: int | None = None
+    need_set_vlan: bool | None = None
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "WlanGuest":
+        return cls(
+            ssid=decode_b64(data.get("ssid", "")),
+            password=decode_b64(data.get("password", "")),
+            enable=bool(data.get("enable", False)),
+            vlan_id=int(data["vlan_id"]) if "vlan_id" in data else None,
+            need_set_vlan=bool(data["need_set_vlan"]) if "need_set_vlan" in data else None,
+        )
+
+
+@dataclass(frozen=True)
+class WlanBackhaul:
+    channel: int
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "WlanBackhaul":
+        return cls(channel=int(data.get("channel", 0)))
+
+
+@dataclass(frozen=True)
+class WlanBand:
+    host: WlanHost
+    guest: WlanGuest
+    backhaul: WlanBackhaul
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "WlanBand":
+        return cls(
+            host=WlanHost.from_api(data.get("host", {})),
+            guest=WlanGuest.from_api(data.get("guest", {})),
+            backhaul=WlanBackhaul.from_api(data.get("backhaul", {})),
+        )
+
+
+@dataclass(frozen=True)
+class IotHost:
+    ssid: str
+    password: str
+    encryption_mode: str
+    enable: bool
+    enable_2g: bool
+    enable_5g: bool
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "IotHost":
+        return cls(
+            ssid=decode_b64(data.get("ssid", "")),
+            password=decode_b64(data.get("password", "")),
+            encryption_mode=data.get("encryption_mode", ""),
+            enable=bool(data.get("enable", False)),
+            enable_2g=bool(data.get("enable_2g", False)),
+            enable_5g=bool(data.get("enable_5g", False)),
+        )
+
+
+@dataclass(frozen=True)
+class MloHost:
+    ssid: str
+    password: str
+    enable: bool
+    band: tuple[str, ...]
+    enable_hide_ssid: bool
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "MloHost":
+        return cls(
+            ssid=decode_b64(data.get("ssid", "")),
+            password=decode_b64(data.get("password", "")),
+            enable=bool(data.get("enable", False)),
+            band=tuple(data.get("band", [])),
+            enable_hide_ssid=bool(data.get("enable_hide_ssid", False)),
+        )
+
+
+@dataclass(frozen=True)
+class WlanConfig:
+    band2_4: WlanBand
+    band5_1: WlanBand
+    band6: WlanBand
+    iot_host: IotHost
+    mlo_host: MloHost
+    is_eg: bool = False
+
+    @classmethod
+    def from_api(cls, data: dict[str, Any]) -> "WlanConfig":
+        return cls(
+            band2_4=WlanBand.from_api(data.get("band2_4", {})),
+            band5_1=WlanBand.from_api(data.get("band5_1", {})),
+            band6=WlanBand.from_api(data.get("band6", {})),
+            iot_host=IotHost.from_api(data.get("iot", {}).get("host", {})),
+            mlo_host=MloHost.from_api(data.get("mlo", {}).get("host", {})),
+            is_eg=bool(data.get("is_eg", False)),
+        )

tplink_deco_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tplink-deco-api
+Version: 0.1.0
+Summary: SDK Python para controle de roteadores TP-Link Deco via API HTTP interna
+Project-URL: Homepage, https://github.com/roquerodrigo/tplink-deco-api
+Project-URL: Repository, https://github.com/roquerodrigo/tplink-deco-api
+Project-URL: Issues, https://github.com/roquerodrigo/tplink-deco-api/issues
+Author-email: Rodrigo Roque <rodrigogoncalvesroque@gmail.com>
+License: MIT
+Keywords: api,deco,mesh,router,sdk,tplink,wifi
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.11
+Requires-Dist: cryptography>=41.0.0
+Description-Content-Type: text/markdown
+
+# tplink-deco-api
+
+SDK Python para controle de roteadores **TP-Link Deco** (mesh Wi-Fi) via API HTTP interna.
+
+## Instalação
+
+```bash
+pip install tplink-deco-api
+```
+
+## Uso
+
+```python
+from tplink_deco import DecoClient
+
+with DecoClient("192.168.68.1", "admin", "sua-senha") as deco:
+    for client in deco.get_client_list():
+        print(client.name, client.ip, client.connection_type)
+```
+
+## Métodos disponíveis
+
+| Método | Retorno |
+|--------|---------|
+| `login()` | `LoginResult` |
+| `get_device_list()` | `list[Device]` |
+| `get_device_mode()` | `DeviceMode` |
+| `get_wlan_config()` | `WlanConfig` |
+| `get_performance()` | `Performance` |
+| `get_client_list(deco_mac?)` | `list[ClientDevice]` |
+
+## Modelos
+
+Todos os métodos retornam dataclasses tipadas — sem dicionários genéricos.
+
+```python
+client.mac              # "AA:BB:CC:DD:EE:FF"
+client.name             # "MacBook Pro"
+client.ip               # "192.168.68.10"
+client.connection_type  # "band6"
+client.online           # True
+
+device.device_model     # "BE65"
+device.software_ver     # "1.2.10 Build 20251229"
+
+wlan.band2_4.host.ssid      # "Minha Rede"
+wlan.band2_4.guest.password # "senha-visitas"
+
+perf.cpu_usage  # 0.03
+perf.mem_usage  # 0.42
+```
+
+## Requisitos
+
+- Python 3.11+
+- Roteador TP-Link Deco acessível na rede local

tplink_deco_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+tplink_deco/__init__.py,sha256=XPiQyGximStuGWqguCStXSbH7bWECD_9_51oRCxUNTA,709
+tplink_deco/client.py,sha256=ezT_8q2ToiyBHJ1ALFXoJYjWgRjnRuny5-q7ad25E-s,4257
+tplink_deco/endpoints.py,sha256=_LWTxdq843DALka7LN8WNRupH3TukU-Cwfeu9Py7mw4,734
+tplink_deco/auth/__init__.py,sha256=RkoPhXrx9uusXxvz7HQlTuZR7lNXtYJE_YpesaNwGLI,253
+tplink_deco/auth/protocol.py,sha256=5Cg_OJb3zYjGLd6uzTpaA4SVxRiyQyqMaXRWbclIV3w,1561
+tplink_deco/auth/session.py,sha256=4rnwj3nF5nD7L0lH0gkMI7X4BI57_YWT_aUWQ3Icm_Y,604
+tplink_deco/auth/transport.py,sha256=9zHgxDOZ3IS6kEmxRao4sqdtZbCpIuTep3STxJkRW4I,1522
+tplink_deco/crypto/__init__.py,sha256=LaJ6X8LVeUWTYqPwBUgwDTpIt0vJTq09Ankcz94qzDo,223
+tplink_deco/crypto/aes.py,sha256=admh7_ehBQpX_evgLnyiRM3nmyl2HvI0ccGHvEYmOOY,1319
+tplink_deco/crypto/hash.py,sha256=lGu0eN3lAgknMR6bo8T7_2LkRgyfRIvMcw2V23BONPA,143
+tplink_deco/crypto/rsa.py,sha256=wlHtmun_2N5EZSLps1XT0EJmC9oy-1PS09xyom47jlw,864
+tplink_deco/exceptions/__init__.py,sha256=rVcvwH972rKvlC22NWnQb5I1x5VbQeA2qGMt0J0Fx2g,255
+tplink_deco/exceptions/api.py,sha256=ZxlqSrXHtJfQL8x_19gE1Z_aPoCbOdVfx8W6P5s3syE,201
+tplink_deco/exceptions/auth.py,sha256=jwsZ_FIhAsFf-MI7fTs98_fwfPZtCqtD67_7kH0vHZ4,77
+tplink_deco/exceptions/base.py,sha256=fItptY8fenLxKaCmt9TnLL9aO-sqjCoBWex7GR7jnY8,37
+tplink_deco/exceptions/crypto.py,sha256=8dM1Oqhm3LgVKgZLJ6nMMtBzchUBdT4GPiGe6dEaccc,69
+tplink_deco/exceptions/transport.py,sha256=wpa7B-CrBCEhtjltUUWyPfm8MVvcElW1MVs3Y6P85Ns,206
+tplink_deco/models/__init__.py,sha256=QAFyTR67p9zw-tmya4_UwAoe9qnUaZblBeT-p9E0n4o,688
+tplink_deco/models/_utils.py,sha256=OeG6AaqOeRIGwH2snQg2nJ1JxVCcutB24K5czeA5EPQ,225
+tplink_deco/models/client_device.py,sha256=cXdrne1-_-BmBO7mRkFARwrVn_l9qIrNfBKbiT3Zhtg,1401
+tplink_deco/models/device.py,sha256=7zkItDQ7Yg_2SttuFdCQJ_-r_Pk6d5Ha42J4xOqmd38,2195
+tplink_deco/models/device_mode.py,sha256=IbBq5EjDT4u1-9gQak56L11M9BBij5ZRJOOadL5rVlo,419
+tplink_deco/models/login_result.py,sha256=I__4ZZ0PB2-D85pLGW2-YFCUrGD7RrTNwBHee0u_3ic,117
+tplink_deco/models/performance.py,sha256=yjP3YsEhid7khtm8gFVNDSD3f_wiPnSVlZLHGp5d6KQ,350
+tplink_deco/models/rsa_key.py,sha256=8giW-niAxntXz37zb8Ct_KKMPdEVwn7SUkumDXw8rH0,254
+tplink_deco/models/session_keys.py,sha256=2biXfh7vX3duZe_N8r0AnTllmZOLfzXN-8RHyhKfwX8,154
+tplink_deco/models/signal_level.py,sha256=Z6NjYV2i8M5nzjqy05GJrmf4GqlyedkLOGIcGplLfg0,366
+tplink_deco/models/wlan_config.py,sha256=6TTt-2L77sb78qjmhXQGYVDQiYs1LINDgpNso7jM7mM,3752
+tplink_deco_api-0.1.0.dist-info/METADATA,sha256=Qv6sh-N4GSQyVZ0Z0jCyrWwULpWomNLm_08qMUnQRaU,2314
+tplink_deco_api-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tplink_deco_api-0.1.0.dist-info/RECORD,,

tplink_deco_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any