speedport-api-expanded 0.7.0__py3-none-any.whl

speedport/__init__.py

@@ -0,0 +1,3 @@
+from .speedport import Speedport
+
+__all__ = ["Speedport"]

speedport/__main__.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+import time
+from getpass import getpass
+from pathlib import Path
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from speedport.speedport import Speedport
+
+_LOGGER = logging.getLogger("speedport")
+
+
+def set_logger(args):
+    logging.getLogger("aiohttp").setLevel(logging.WARNING)
+    if args["debug"]:
+        _LOGGER.setLevel(logging.DEBUG)
+        formatter = logging.Formatter("%(levelname)s - %(message)s")
+    elif args["quiet"]:
+        _LOGGER.setLevel(logging.WARNING)
+        formatter = logging.Formatter("%(message)s")
+    else:
+        _LOGGER.setLevel(logging.INFO)
+        formatter = logging.Formatter("%(message)s")
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    _LOGGER.addHandler(console_handler)
+
+
+def data_table(data, keys):
+    columns = {}
+    for key in keys:
+        columns[key] = max([len(str(d[key])) for d in data] + [len(key)])
+    line = (
+        "+-"
+        + "-+-".join([f"{'-' * length}" for key, length in columns.items()])
+        + "-+\n"
+    )
+    text = (
+        f"{line}| "
+        + " | ".join([f"{key:<{length}}" for key, length in columns.items()])
+        + f" |\n{line}"
+    )
+    for d in data:
+        text += (
+            "| "
+            + " | ".join(
+                [f"{str(d[key]):<{length}}" for key, length in columns.items()]
+            )
+            + " |\n"
+        )
+    return text + line
+
+
+def batch_output(devices):
+    for device in devices.values():
+        print(
+            int(device.connected),
+            device.ipv4,
+            device.type,
+            device.name,
+            sep="\t",
+        )
+
+
+def get_arguments():
+    """Get parsed arguments."""
+    parser = argparse.ArgumentParser(description="Speedport: Command Line Utility")
+    parser.add_argument(
+        "-H",
+        "--host",
+        help="ip address or hostname of Speedport webinterface",
+        default=os.environ.get("SPEEDPORT_HOST", "speedport.ip"),
+    )
+    parser.add_argument(
+        "-s", "--https", help="use https connection", action="store_true"
+    )
+    parser.add_argument(
+        "-p",
+        "--password",
+        help="password of Speedport webinterface (default: SPEEDPORT_PASSWORD)",
+        default=os.environ.get("SPEEDPORT_PASSWORD"),
+    )
+    parser.add_argument(
+        "-d", "--debug", help="enable debug logging", action="store_true"
+    )
+    parser.add_argument("-q", "--quiet", help="output only errors", action="store_true")
+    parser.add_argument(
+        "-b", "--batch", help="print output for batch processing", action="store_true"
+    )
+    parser.add_argument(
+        "-t", "--table", help="print output as table (default)", action="store_true"
+    )
+    subparser = parser.add_subparsers(
+        title="commands", metavar="COMMAND", required=True
+    )
+    for network in ["", "guest-", "office-"]:
+        wifi = subparser.add_parser(f"{network}wifi", help=f"Turn on/off {network}wifi")
+        wifi.add_argument(
+            f"{network}wifi", choices=["on", "off"], help=f"Turn on/off {network}wifi"
+        )
+    reconnect = subparser.add_parser(
+        "reconnect", help="Reconnect internet and receive new ip"
+    )
+    reconnect.set_defaults(reconnect=True)
+    reboot = subparser.add_parser("reboot", help="Reboot device")
+    reboot.set_defaults(reboot=True)
+    wps = subparser.add_parser("wps", help="Turn on wps for 2 minutes")
+    wps.set_defaults(wps=True)
+    devices = subparser.add_parser("devices", help="Output devices")
+    devices.set_defaults(devices=True)
+    calls = subparser.add_parser("calls", help="Output calls")
+    calls.set_defaults(calls=True)
+    ip_info = subparser.add_parser("ip-info", help="Output IPv4 and IPv6 information")
+    ip_info.set_defaults(ip_info=True)
+    ip_info.add_argument(
+        "--ipv4", help="Print only the public IPv4 address", action="store_true"
+    )
+    return vars(parser.parse_args())
+
+
+async def check_args(speedport, args):
+    if args.get("ip_info"):
+        info = await speedport.ip_info
+        if args.get("ipv4"):
+            address = info.get("public_ip_v4")
+            if not address:
+                raise SystemExit("Router did not report a public IPv4 address")
+            print(address)
+        elif args.get("batch"):
+            for key, value in info.items():
+                print(key, value, sep="\t")
+        else:
+            print(
+                data_table(
+                    [{"field": key, "value": value} for key, value in info.items()],
+                    ["field", "value"],
+                )
+            )
+    if args.get("wps"):
+        await wps_enable(args, speedport)
+    if args.get("reconnect"):
+        await reconnect(args, speedport)
+    if args.get("reboot"):
+        await speedport.reboot()
+    if args.get("devices"):
+        if args.get("batch"):
+            batch_output(await speedport.devices)
+        else:
+            print(
+                data_table(
+                    (await speedport.devices).values(),
+                    ["ipv4", "name", "type", "connected"],
+                )
+            )
+    if args.get("calls"):
+        if args.get("batch"):
+            batch_output(await speedport.devices)
+        else:
+            print(
+                data_table(
+                    await speedport.calls,
+                    ["number", "type", "duration", "date"],
+                )
+            )
+
+
+async def check_wifi_args(speedport, args):
+    if args.get("wifi") and args["wifi"] == "on":
+        await speedport.wifi_on()
+    elif args.get("wifi") and args["wifi"] == "off":
+        await speedport.wifi_off()
+    if args.get("guest-wifi") and args["guest-wifi"] == "on":
+        await speedport.wifi_guest_on()
+    elif args.get("guest-wifi") and args["guest-wifi"] == "off":
+        await speedport.wifi_guest_off()
+    if args.get("office-wifi") and args["office-wifi"] == "on":
+        await speedport.wifi_office_on()
+    elif args.get("office-wifi") and args["office-wifi"] == "off":
+        await speedport.wifi_office_off()
+
+
+async def main():
+    args = get_arguments()
+    set_logger(args)
+    password = ""
+    if not args.get("devices"):
+        if not (password := args["password"]):
+            password = getpass("Password of Speedports webinterface: ")
+    async with Speedport(args["host"], password, args.get("https")) as speedport:
+        await check_wifi_args(speedport, args)
+        await check_args(speedport, args)
+
+
+async def reconnect(args, speedport):
+    if not args.get("quiet"):
+        await speedport.update_ip_data()
+        _LOGGER.info(f"{speedport.public_ip_v4} / {speedport.public_ip_v6}")
+    await speedport.reconnect()
+    if not args.get("quiet"):
+        for i in range(240):
+            await speedport.update_ip_data()
+            if await speedport.online_status == "online":
+                _LOGGER.info(f"{speedport.public_ip_v4} / {speedport.public_ip_v6}")
+                break
+            await asyncio.sleep(0.5)
+            print(f"Connecting.{'.' * (i % 3)}  ", end="\r", flush=True)
+
+
+async def wps_enable(args, speedport):
+    await speedport.wps_on()
+    if not args.get("quiet"):
+        event = time.time()
+        next_time = event
+        while await speedport.wps_state == 1:
+            await asyncio.sleep(next_time - time.time())
+            next_time = time.time() + 1
+            print(
+                f"wps connect enabled for {120 - int(time.time() - event)}s...",
+                end="\r",
+                flush=True,
+            )
+
+
+def start():
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Aborted.")
+
+
+if __name__ == "__main__":
+    start()

speedport/api.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import functools
+import logging
+from datetime import datetime, timedelta
+
+import aiohttp
+
+from speedport import exceptions
+from speedport.connection import Connection
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def need_auth(func):
+    @functools.wraps(func)
+    async def inner(self: "SpeedportApi", *args, **kwargs):
+        if not self.api.is_logged_in:
+            if not self.password:
+                error = f'You need to set a password to use "{func.__name__}"'
+                _LOGGER.error(error)
+                raise PermissionError(error)
+            await self.api.login(self.password)
+        try:
+            return await func(self, *args, **kwargs)
+        except exceptions.DecryptionKeyError as exception:
+            if not self.last_logout:
+                _LOGGER.info(f"Paused fetching for {self.pause_time} min")
+                self.last_logout = datetime.now()
+            if datetime.now() > (
+                time := self.last_logout + timedelta(minutes=self.pause_time)
+            ):
+                self.last_logout = None
+                await self.api.login(self.password)
+                return await func(self, *args, **kwargs)
+            remaining = time - datetime.now()
+            error = f"Paused for 00:{remaining.seconds // 60:02d}:{remaining.seconds % 60:02d}"
+            _LOGGER.debug(error)
+            raise exceptions.LoginPausedError(error) from exception
+
+    return inner
+
+
+class SpeedportApi:
+    def __init__(
+        self,
+        host: str = "speedport.ip",
+        password: str = "",
+        https: bool = False,
+        session: aiohttp.ClientSession | None = None,
+        pause_time: int = 5,
+    ):
+        self._api: Connection | None = None
+        self._host: str = host
+        self._password: str = password
+        self._https: bool = https
+        self._url = f"https://{host}" if https else f"http://{host}"
+        self._session: aiohttp.ClientSession | None = session
+        self._pause_time: int = pause_time
+        self._last_logout: datetime | None = None
+
+    async def __aenter__(self):
+        return await self.create()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def create(self):
+        self._api = await Connection(self._url, self._session).create()
+        return self
+
+    async def close(self):
+        if self._api:
+            await self._api.close()
+
+    @property
+    def api(self) -> Connection:
+        if self._api:
+            return self._api
+        raise ConnectionError()
+
+    @property
+    def password(self) -> str:
+        return self._password
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def pause_time(self) -> int:
+        return self._pause_time
+
+    @pause_time.setter
+    def pause_time(self, pause_time: int):
+        self._pause_time = pause_time
+
+    @property
+    def last_logout(self) -> datetime | None:
+        return self._last_logout
+
+    @last_logout.setter
+    def last_logout(self, last_logout: datetime | None):
+        self._last_logout = last_logout
+
+    @need_auth
+    async def get_secure_status(self):
+        return await self.api.get("data/SecureStatus.json", auth=True)
+
+    @need_auth
+    async def get_phone_handler(self):
+        return await self.api.get("data/IPPhoneHandler.json", auth=True)
+
+    async def get_router(self):
+        return await self.api.get("data/Router.json")
+
+    async def get_status(self):
+        return await self.api.get("data/Status.json")
+
+    async def get_devices(self):
+        return await self.api.get("data/DeviceList.json")
+
+    async def get_login(self):
+        return await self.api.get("data/Login.json")
+
+    @need_auth
+    async def get_ip_data(self):
+        referer = "html/content/internet/con_ipdata.html"
+        return await self.api.get("data/IPData.json", referer=referer, auth=True)
+
+    @need_auth
+    async def get_wps_state(self):
+        referer = "html/content/network/wlan_wps.html"
+        return await self.api.get("data/WPSStatus.json", referer=referer)
+
+    @need_auth
+    async def get_phone_calls(self):
+        referer = "html/content/phone/phone_call_taken.html"
+        return await self.api.get("data/PhoneCalls.json", referer=referer, auth=True)
+
+    @need_auth
+    async def set_wifi(self, status=True, guest=False, office=False):
+        """Set wifi on/off"""
+        extra = "guest" if guest else "office" if office else ""
+        _LOGGER.info(
+            "Turn %s %s wifi...", ["off", "on"][bool(status)], extra if extra else ""
+        )
+        data = (
+            {f"wlan_{extra}_active": str(int(status))}
+            if extra
+            else {"use_wlan": str(int(status))}
+        )
+        referer = f"html/content/network/wlan_{extra if extra else 'basic'}.html"
+        return await self.api.post(
+            f"data/{'WLANBasic' if extra else 'Modules'}.json", data, referer
+        )
+
+    @need_auth
+    async def wps_on(self):
+        _LOGGER.info("Enable wps connect...")
+        await self.api.post(
+            "data/WLANAccess.json",
+            {"wlan_add": "on", "wps_key": "connect"},
+            "html/content/network/wlan_wps.html",
+        )
+
+    @need_auth
+    async def reconnect(self):
+        _LOGGER.info("Reconnect with internet provider...")
+        await self.api.post(
+            "data/Connect.json",
+            {"req_connect": "reconnect"},
+            "html/content/internet/con_ipdata.html",
+        )
+
+    @need_auth
+    async def reboot(self):
+        _LOGGER.info("Reboot speedport...")
+        await self.api.post(
+            "data/Reboot.json",
+            {"reboot_device": "true"},
+            "html/content/config/restart.html",
+        )
+
+    async def login(self, password=""):
+        return await self.api.login(password or self.password)

speedport/call.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+
+class Call:
+    def __init__(self, data, call_type):
+        self._data = data
+        self._call_type = call_type
+
+    def __str__(self):
+        return self.number
+
+    def __repr__(self):
+        return f"{self.__class__} ({self.__dict__})"
+
+    def __getitem__(self, item):
+        try:
+            return self.__getattribute__(item)
+        except AttributeError:
+            return self._data.get(
+                f"{self._call_type}_{item}", self.__getattribute__(item)
+            )
+
+    @property
+    def data(self):
+        return self._data
+
+    @property
+    def type(self):
+        return self._call_type.replace("calls", "")
+
+    @property
+    def connection(self):
+        return self._data.get(f"{self._call_type}_as")
+
+    @property
+    def duration(self):
+        return int(self._data.get(f"{self._call_type}_duration", 0))
+
+    @property
+    def date(self):
+        date = f'{self._data.get(f"{self._call_type}_date")} {self._data.get(f"{self._call_type}_time")}'
+        return datetime.strptime(date, "%d.%m.%y %H:%M:%S")
+
+    @property
+    def number(self):
+        return self._data.get(f"{self._call_type}_who")

speedport/connection.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from hashlib import sha256
+from json import JSONDecodeError
+
+import aiohttp
+from Crypto.Cipher import AES
+
+from speedport import const, exceptions
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def decode(data, key: str = "") -> dict[str, list | dict | str] | str:
+    """Decode speedport's self-implemented encryption"""
+    key = key or const.DEFAULT_KEY
+    try:
+        ciphertext_tag = bytes.fromhex(data)
+    except ValueError as exc:
+        raise exceptions.DecryptionKeyError("Wrong decryption key") from exc
+    cipher = AES.new(bytes.fromhex(key), AES.MODE_CCM, bytes.fromhex(key)[:8])
+    decrypted = cipher.decrypt_and_verify(ciphertext_tag[:-16], ciphertext_tag[-16:])
+    try:
+        return simplify_response(json.loads(decrypted.decode()))
+    except JSONDecodeError:
+        return decrypted.decode()
+
+
+def encode(data, key: str = "") -> str:
+    """Encode for speedport's self-implemented encryption"""
+    key = key or const.DEFAULT_KEY
+    cipher = AES.new(bytes.fromhex(key), AES.MODE_CCM, bytes.fromhex(key)[:8])
+    ciphertext, tag = cipher.encrypt_and_digest(data.encode())
+    return ciphertext.hex() + tag.hex()
+
+
+def simplify_response(
+    data: list[dict[str, str | list[dict[str, str]]]],
+) -> dict[str, list | dict | str]:
+    """Remove 'varid' and 'varvalue' to have a flatter data structure without overhead"""
+    result = {}
+    for item in data:
+        if isinstance(item["varvalue"], list):
+            list_item = {}
+            for sub_item in item["varvalue"]:
+                list_item[sub_item["varid"]] = sub_item["varvalue"]
+            result.setdefault(item["varid"], []).append(list_item)
+        else:
+            result[item["varid"]] = item["varvalue"]
+    return result
+
+
+class Connection:
+    def __init__(
+        self,
+        host_url: str = "",
+        session: aiohttp.ClientSession | None = None,
+    ):
+        self._login_key = ""
+        self._url = host_url
+        self._own_session = session is None
+        self._session: aiohttp.ClientSession | None = session
+        self._verify_ssl: bool = False
+        self._timeout: float = 30
+
+    async def __aenter__(self):
+        return await self.create()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    @property
+    def _kwargs(self):
+        return {"verify_ssl": self._verify_ssl, "timeout": self._timeout}
+
+    async def create(self) -> Connection:
+        """Create aiohttp session"""
+        connector = aiohttp.TCPConnector(verify_ssl=self._verify_ssl)
+        if not self._session:
+            jar = aiohttp.CookieJar(unsafe=True)
+            self._session = aiohttp.ClientSession(connector=connector, cookie_jar=jar)
+        else:
+            self._session.cookie_jar._unsafe = True
+        return self
+
+    async def close(self):
+        """Close aiohttp session"""
+        if self._own_session:
+            await self._session.close()
+
+    async def get(self, path: str, auth: bool = False, referer: str = ""):
+        url = f"{self._url}/{path}"
+        if referer:
+            referer = f"{self._url}/{referer}"
+            if token := await self._get_httoken(referer):
+                url += f"?_tn={token}"
+        async with self._session.get(
+            url, headers={"Referer": referer}, **self._kwargs
+        ) as response:
+            _LOGGER.debug("GET - %s - %s", url, response.status)
+            key = self._login_key if auth else const.DEFAULT_KEY
+            return decode(await response.text(), key=key)
+
+    async def post(self, path: str, data: dict[str, str], referer: str):
+        url = f"{self._url}/{path}"
+        referer = f"{self._url}/{referer}"
+        if token := await self._get_httoken(referer):
+            data.update({"httoken": token})
+        data = "&".join([f"{k}={v}" for k, v in data.items()])
+        data = encode(data, key=self._login_key)
+        async with self._session.post(
+            url, headers={"Referer": referer}, data=data, **self._kwargs
+        ) as response:
+            _LOGGER.debug("POST - %s - %s", url, response.status)
+            return decode(await response.text(), key=self._login_key)
+
+    async def _get_httoken(self, url: str) -> str:
+        async with self._session.get(url, **self._kwargs) as response:
+            _LOGGER.debug("GET - %s - %s", url, response.status)
+            if token := re.findall("httoken = (\\d+)", await response.text()):
+                return token[0]
+            return ""
+
+    async def _get_login_key(self):
+        data = {"getChallenge": "1"}
+        if response := await self.post("data/Login.json", data, "/"):
+            self._login_key = response["challenge"]
+        return self._login_key
+
+    async def login(self, password: str):
+        url = f"{self._url}/data/Login.json"
+        self.clear()
+        login_data = f"{await self._get_login_key()}:{password}".encode()
+        login_key = sha256(login_data).hexdigest()
+        data = encode("showpw=0&password=" + login_key)
+        async with self._session.post(url, data=data, **self._kwargs) as response:
+            _LOGGER.debug("POST - %s - %s", url, response.status)
+            result = decode(await response.text())
+            _LOGGER.debug(result)
+        if (sleep_time := result.get("login_locked")) and int(sleep_time) < 60:
+            _LOGGER.warning("Can't login, wait %ss...", sleep_time)
+            await asyncio.sleep(int(sleep_time) + 1)
+            return await self.login(password)
+        if result["login"] != "success":
+            _LOGGER.error(result)
+            raise exceptions.LoginException("Can't login")
+        return result["login"]
+
+    @property
+    def is_logged_in(self):
+        return bool(self._login_key)
+
+    def clear(self):
+        self._login_key = ""
+        self._session.cookie_jar.clear_domain(self._url)

speedport/const.py

@@ -0,0 +1,2 @@
+# Is this the default key for everyone or should we parse it?
+DEFAULT_KEY = "cdc0cac1280b516e674f0057e4929bca84447cca8425007e33a88a5cf598a190"

speedport/device.py

@@ -0,0 +1,87 @@
+class WlanDevice:
+    def __init__(self, data):
+        self._data = data
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return f"{self.__class__} ({self.__dict__})"
+
+    def __getitem__(self, item):
+        try:
+            return self.__getattribute__(item)
+        except AttributeError:
+            return self._data.get(f"mdevice_{item}", self._data.get(item))
+
+    @property
+    def data(self):
+        return self._data
+
+    @property
+    def connected(self):
+        return bool(int(self._data.get("mdevice_connected") or "0"))
+
+    @property
+    def downspeed(self):
+        return int(self._data.get("mdevice_downspeed") or "0")
+
+    @property
+    def fix_dhcp(self):
+        return bool(int(self._data.get("mdevice_fix_dhcp") or "0"))
+
+    @property
+    def gua_ipv6(self):
+        return self._data.get("mdevice_gua_ipv6")
+
+    @property
+    def hasui(self):
+        return int(self._data.get("mdevice_hasui") or "0")
+
+    @property
+    def ipv4(self):
+        return self._data.get("mdevice_ipv4")
+
+    @property
+    def mac(self):
+        return self._data.get("mdevice_mac")
+
+    @property
+    def name(self):
+        return self._data.get("mdevice_name")
+
+    @property
+    def reservedip(self):
+        return self._data.get("mdevice_reservedip")
+
+    @property
+    def rssi(self):
+        return int(self._data.get("mdevice_rssi") or "0")
+
+    @property
+    def slave(self):
+        return bool(int(self._data.get("mdevice_slave") or "0"))
+
+    @property
+    def type(self):
+        return ["lan", "wlan", "wlan5"][int(self._data.get("mdevice_type", "0")) % 3]
+
+    @property
+    def ula_ipv6(self):
+        return self._data.get("mdevice_ula_ipv6")
+
+    @property
+    def upspeed(self):
+        return int(self._data.get("mdevice_upspeed") or "0")
+
+    @property
+    def use_dhcp(self):
+        return bool(int(self._data.get("mdevice_use_dhcp") or "0"))
+
+    @property
+    def wifi(self):
+        return int(self._data.get("mdevice_wifi") or "0")
+
+    @property
+    def id(self):
+        return int(self._data.get("id") or "0")

speedport/exceptions.py

@@ -0,0 +1,10 @@
+class LoginException(Exception):
+    pass
+
+
+class DecryptionKeyError(PermissionError):
+    pass
+
+
+class LoginPausedError(PermissionError):
+    pass

speedport/speedport.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import logging
+from contextlib import suppress
+from datetime import datetime
+
+import aiohttp
+
+from . import exceptions
+from .api import SpeedportApi
+from .call import Call
+from .device import WlanDevice
+
+_LOGGER = logging.getLogger(__name__)
+_LOGGER.setLevel(logging.WARNING)
+
+
+class LoginException(Exception):
+    pass
+
+
+class Speedport:
+    def __init__(
+        self,
+        host: str = "speedport.ip",
+        password: str = "",
+        https: bool = False,
+        session: aiohttp.ClientSession | None = None,
+        pause_time: int = 5,
+    ):
+        self._api: SpeedportApi | None = None
+        self._host: str = host
+        self._password: str = password
+        self._https: bool = https
+        self._session: aiohttp.ClientSession | None = session
+        self._status = {}
+        self._ip_data = {}
+        self._pause_time = pause_time
+
+    async def __aenter__(self):
+        return await self.create()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    def __getitem__(self, item):
+        if (status := self._status.get(item)) is not None:
+            return status
+        if (ip_data := self._ip_data.get(item)) is not None:
+            return ip_data
+        raise KeyError
+
+    def get(self, item, default=None):
+        try:
+            return self[item]
+        except KeyError:
+            return default
+
+    async def create(self):
+        self._api = await SpeedportApi(
+            self._host, self._password, self._https, self._session, self._pause_time
+        ).create()
+        await self.update_status()
+        return self
+
+    async def close(self):
+        if self._api:
+            await self._api.close()
+
+    def set_pause_time(self, pause_time: int):
+        if self._api:
+            self._api.pause_time = pause_time
+        self._pause_time = pause_time
+
+    @property
+    def api(self) -> SpeedportApi:
+        if self._api:
+            return self._api
+        raise ConnectionError()
+
+    @property
+    async def devices(self) -> dict[str, WlanDevice]:
+        data = await self.api.get_devices()
+        devices = data.get("addmlandevice", []) + data.get("addmwlan5device", [])
+        devices += data.get("addmwlandevice", []) + data.get("addmdevice", [])
+        devices = sorted(devices, key=lambda d: int(d["mdevice_ipv4"].split(".")[-1]))
+        return {device.get("mdevice_mac"): WlanDevice(device) for device in devices}
+
+    @property
+    async def calls(self) -> list[Call]:
+        data = await self.api.get_phone_calls()
+        types = ["dialedcalls", "missedcalls", "takencalls"]
+        result: list[Call] = []
+        for call_type in types:
+            for call in data.get(f"add{call_type}"):
+                result.append(Call(call, call_type))
+        result.sort(key=lambda d: d.date)
+        return result
+
+    async def wifi_on(self):
+        await self.api.set_wifi(status=True, guest=False)
+
+    async def wifi_off(self):
+        await self.api.set_wifi(status=False, guest=False)
+
+    async def wps_on(self):
+        await self.api.wps_on()
+
+    async def reconnect(self):
+        await self.api.reconnect()
+
+    async def reboot(self):
+        await self.api.reboot()
+
+    async def wifi_guest_on(self):
+        await self.api.set_wifi(status=True, guest=True)
+
+    async def wifi_guest_off(self):
+        await self.api.set_wifi(status=False, guest=True)
+
+    async def wifi_office_on(self):
+        await self.api.set_wifi(status=True, office=True)
+
+    async def wifi_office_off(self):
+        await self.api.set_wifi(status=False, office=True)
+
+    async def update_ip_data(self):
+        with suppress(exceptions.LoginPausedError):
+            self._ip_data = await self.api.get_ip_data()
+
+    @property
+    async def ip_info(self) -> dict:
+        """Fetch IPv4/IPv6 addresses, gateways, DNS servers and IPv6 prefixes."""
+        self._ip_data = await self.api.get_ip_data()
+        return self._ip_data.copy()
+
+    async def update_status(self):
+        self._status = await self.api.get_status()
+
+    @property
+    def device_name(self):
+        return self._status.get("device_name", "")
+
+    @property
+    def serial_number(self):
+        return self._status.get("serial_number", "")
+
+    @property
+    def firmware_version(self):
+        return self._status.get("firmware_version", "")
+
+    @property
+    def dsl_downstream(self):
+        return int(self._status.get("dsl_downstream", "0"))
+
+    @property
+    def dsl_upstream(self):
+        return int(self._status.get("dsl_upstream", "0"))
+
+    @property
+    def inet_download(self):
+        return int(self._status.get("inet_download", "0"))
+
+    @property
+    def inet_upload(self):
+        return int(self._status.get("inet_upload", "0"))
+
+    @property
+    def inet_uptime(self):
+        return datetime.fromisoformat(self._status.get("inet_uptime"))
+
+    @property
+    def online_status(self):
+        return self._status.get("onlinestatus", "")
+
+    @property
+    def login_state(self):
+        return bool(self._status.get("loginstate"))
+
+    @property
+    def rebooting(self):
+        return bool(self._status.get("rebooting"))
+
+    @property
+    def wlan_active(self):
+        return bool(int(self._status.get("use_wlan")))
+
+    @property
+    def wlan_guest_active(self):
+        return bool(int(self._status.get("wlan_guest_active")))
+
+    @property
+    def wlan_office_active(self):
+        return bool(int(self._status.get("wlan_office_active")))
+
+    @property
+    def wlan_ssid(self):
+        return self._status.get("wlan_ssid")
+
+    @property
+    def wlan_guest_ssid(self):
+        return self._status.get("wlan_guest_ssid")
+
+    @property
+    def wlan_office_ssid(self):
+        return self._status.get("wlan_office_ssid")
+
+    @property
+    def dns_v4(self):
+        return self._ip_data.get("dns_v4", "")
+
+    @property
+    def dns_v6(self):
+        return self._ip_data.get("dns_v6", "")
+
+    @property
+    def gateway_ip_v4(self):
+        return self._ip_data.get("gateway_ip_v4", "")
+
+    @property
+    def gateway_ip_v6(self):
+        return self._ip_data.get("gateway_ip_v6", "")
+
+    @property
+    def public_ip_v4(self):
+        return self._ip_data.get("public_ip_v4", "")
+
+    @property
+    def public_ip_v6(self):
+        return self._ip_data.get("public_ip_v6", "")
+
+    @property
+    def sec_dns_v4(self):
+        return self._ip_data.get("sec_dns_v4", "")
+
+    @property
+    def sec_dns_v6(self):
+        return self._ip_data.get("sec_dns_v6", "")
+
+    @property
+    def transmitted_ip_v6_pool_for_lan(self):
+        return self._ip_data.get("transmitted_ip_v6_pool_for_lan", "")
+
+    @property
+    def used_ip_v6_lan(self):
+        return self._ip_data.get("used_ip_v6_lan", "")
+
+    @property
+    async def wps_remaining(self):
+        return int((await self.api.get_wps_state())["wlan_wps_state"])
+
+    async def login(self, password=""):
+        return await self.api.login(password or self._password)

speedport_api_expanded-0.7.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: speedport-api-expanded
+Version: 0.7.0
+Summary: Control Telekom Speedport routers with Python
+Home-page: https://github.com/kplrm/speedport-api-expanded
+Author: Andre Basche, Diego Guillen-Rosaperez
+Maintainer: Diego Guillen-Rosaperez
+License: MIT
+Project-URL: GitHub, https://github.com/kplrm/speedport-api-expanded
+Project-URL: PyPI, https://pypi.org/project/speedport-api-expanded/
+Project-URL: Upstream, https://github.com/Andre0512/speedport-api
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8
+Requires-Dist: pycryptodome>=3.18
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: platform
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+**This python package is unofficial and is not related in any way to Telekom. It was developed by reversed engineered http requests and can stop working at anytime!**
+  
+## Speedport-API
+[![PyPI - Status](https://img.shields.io/pypi/status/speedport-api-expanded)](https://pypi.org/project/speedport-api-expanded/)
+[![PyPI](https://img.shields.io/pypi/v/speedport-api-expanded?color=blue)](https://pypi.org/project/speedport-api-expanded/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/speedport-api-expanded)](https://www.python.org/)
+[![PyPI - License](https://img.shields.io/pypi/l/speedport-api-expanded)](https://github.com/kplrm/speedport-api-expanded/blob/main/LICENSE)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/speedport-api-expanded)](https://pypistats.org/packages/speedport-api-expanded)
+
+Control Telekom Speedport routers with Python!
+
+### Installation
+```commandline
+pip install speedport-api-expanded
+```
+
+For this fork's changes, install from a checkout with `python -m pip install -e .`
+or download a wheel from [GitHub releases](https://github.com/kplrm/speedport-api-expanded/releases).
+The Python import remains `from speedport import Speedport`.
+See [local development and adding features](docs/development.md),
+[contribution guidelines](CONTRIBUTING.md), and [contributors](CONTRIBUTORS.md).
+Store local router credentials in an
+ignored `.env` copied from [.env.example](.env.example); see the guide for loading it.
+
+### Supported Devices
+* Speedport Smart 4
+
+### Commandline tool
+With this shipped commandline tool can a speedport in your network be controlled.
+
+#### Turn wifi off
+```commandline
+$ speedport wifi off
+Turn off wifi...
+```
+
+#### Turn guest wifi on
+```commandline
+$ speedport guest-wifi on
+Turn on guest wifi...
+```
+
+#### Reconnect for new ip address
+```commandline
+$ speedport reconnect
+123.45.67.89 / 5403:f3:35aa:12f:7287:41cf:fb1c:3c83
+Reconnect with internet provider...
+123.45.67.12 / 5403:f3:35fe:12f:7287:41cf:fb1c:3c83
+```
+
+#### Query IPv4 and IPv6 information
+```commandline
+speedport --host 192.168.2.1 ip-info
+speedport --host 192.168.2.1 --batch ip-info
+```
+Prints addresses, gateways, primary/secondary DNS servers, and IPv6 prefixes.
+Batch output uses tab-separated field/value pairs. A password is prompted for
+unless `SPEEDPORT_PASSWORD` is set.
+
+To print only the public IPv4 address, without a label or table:
+```commandline
+python -m speedport --host 192.168.2.1 ip-info --ipv4
+93.218.250.118
+```
+If no public IPv4 address is available, the command exits with an error.
+
+#### Enable wps connect
+```commandline
+$ speedport wps
+Enable wps connect...
+wps connect enabled for 113s...
+```
+
+#### Reboot device
+```commandline
+$ speedport reboot
+Reboot speedport...
+```
+
+#### Print devices
+```commandline
+$ speedport devices
++-------------+---------------------+-------+-----------+
+| ipv4        | name                | type  | connected |
++-------------+---------------------+-------+-----------+
+| 10.5.12.32  | Google-Home-Mini-1  | wlan  | 1         |
+| 10.5.12.157 | PC10-5-12-157       | lan   | 0         |
+| 10.5.12.227 | andre-xps           | wlan5 | 1         |
+```
+
+
+#### Print calls
+```commandline
+$ speedport calls
++-------------+--------+----------+---------------------+
+| number      | type   | duration | date                |
++-------------+--------+----------+---------------------+
+| 01578212345 | missed | 0        | 2024-04-04 09:34:35 |
+| 026361245   | taken  | 1337     | 2024-04-06 05:12:53 |
+| 7866        | dialed | 20       | 2024-04-06 18:39:00 |
+```
+
+### Library
+
+#### IP information example
+```python
+import asyncio
+import os
+from speedport import Speedport
+
+async def ip_info():
+    async with Speedport(
+        os.environ.get("SPEEDPORT_HOST", "192.168.2.1"),
+        os.environ["SPEEDPORT_PASSWORD"],
+    ) as router:
+        info = await router.ip_info
+        print(info["public_ip_v4"], info["public_ip_v6"])
+        print(info)  # All fields, including DNS servers and IPv6 prefixes.
+
+asyncio.run(ip_info())
+```
+
+#### Reconnect example
+```python
+import asyncio
+from speedport import Speedport
+
+async def reconnect():
+    speedport =  Speedport("192.168.1.1")
+    await speedport.login("password123")
+    await speedport.reconnect()
+
+asyncio.run(reconnect())
+```
+
+#### Devices example
+```python
+import asyncio
+from speedport import Speedport
+
+devices = asyncio.run(Speedport().devices)
+for device in devices:
+    print(device.ipv4, device.connected)
+```

speedport_api_expanded-0.7.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+speedport/__init__.py,sha256=emHP7xbzqtem60b6_C2V-8Iks9eCwB8iWFdJirC2hPU,58
+speedport/__main__.py,sha256=37TJblmz-CM6jybaLkHdqiDQv0oe7Wz2pK8gkxWx3D0,7765
+speedport/api.py,sha256=sAWBA12UZL1Id01ptHMLAG7IGyxT-MKYnt2x7PPsSog,5824
+speedport/call.py,sha256=OopvZcyz6n49ngLL2PezTTaN-UGtZil1aomMGVQdyYM,1169
+speedport/connection.py,sha256=yYxBoDxRemV7cFUdFs9yIlTCLm81bK-MVR7ZgrtEWkE,5877
+speedport/const.py,sha256=TFSJKaDPKUdOnepb2MUzpe1ecnaMOtMvoN0dBFUUwp8,143
+speedport/device.py,sha256=XvOkcg0sxaRIGJKp_Z1VGo6TQJSOIPngNFFyIQ2IdDI,2083
+speedport/exceptions.py,sha256=RLqgPTXKEE1m20egEgvei3mrOMT9sqjCj4X8iRv5P_g,148
+speedport/speedport.py,sha256=ydpxvWjSfP9acxpeHBucf_uLMBIUXHnSpl0C4FyPAaE,6958
+speedport_api_expanded-0.7.0.dist-info/licenses/LICENSE,sha256=j4F0U6fAmiZRpjNhTlP7Q6PiK_3kHxyoEgB6ura82aA,1112
+speedport_api_expanded-0.7.0.dist-info/METADATA,sha256=4QHCELF8QDY419qMlRsPYOxXxSyByl42Fi16AGwDgUI,6028
+speedport_api_expanded-0.7.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+speedport_api_expanded-0.7.0.dist-info/entry_points.txt,sha256=iMYZzg3YJVhauEu-I6QC8lQHvQEdueA4gjwriyHDYnY,55
+speedport_api_expanded-0.7.0.dist-info/top_level.txt,sha256=9AObLD9lR2H0X-nJfCceDaKNdR5y2PV55HveX05H-b8,10
+speedport_api_expanded-0.7.0.dist-info/RECORD,,

speedport_api_expanded-0.7.0.dist-info/WHEEL

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

speedport_api_expanded-0.7.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+speedport = speedport.__main__:start

speedport_api_expanded-0.7.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022 Andre Basche
+Copyright (c) 2026 Diego Guillen-Rosaperez
+
+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.

speedport_api_expanded-0.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+speedport