fastmile-parser 0.1.0__py3-none-any.whl

fastmile_parser/__init__.py

@@ -0,0 +1 @@
+"""FastMile parser package."""

fastmile_parser/models.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(slots=True)
+class DeviceInfo:
+    model: str
+    software_version: str
+    serial_number: str
+    imei: str
+    imsi: str
+    mac: str
+    lock_status: str
+
+
+@dataclass(slots=True)
+class TrafficValue:
+    val: float
+    unit: str
+    val_gb: float
+
+
+@dataclass(slots=True)
+class InterfaceData:
+    download: TrafficValue
+    upload: TrafficValue
+
+
+@dataclass(slots=True)
+class ApnInfo:
+    name: str
+    ipv4: Optional[str]
+    ipv6: Optional[str]
+
+
+@dataclass(slots=True)
+class CaInfo:
+    enb: int
+    cid: int
+    dl_bands: list[int]
+    ul_bands: list[int]
+
+
+@dataclass(slots=True)
+class CellSignal:
+    pci: int
+    earfcn: int
+    cell_type: Optional[str]
+    rsrp: int
+    rsrq: int
+    rssi: int
+    sinr: int
+
+
+@dataclass(slots=True)
+class LteInfo:
+    ca: CaInfo
+    active: list[CellSignal]
+    available: list[CellSignal]
+
+
+@dataclass(slots=True)
+class SnapshotData:
+    eth: InterfaceData
+    lte: InterfaceData
+
+
+@dataclass(slots=True)
+class Snapshot:
+    device: DeviceInfo
+    apns: list[ApnInfo]
+    data: SnapshotData
+    lte: LteInfo

fastmile_parser/router_client.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import requests
+
+
+class RouterClient:
+    def __init__(self, host: str, timeout: int = 30) -> None:
+        self.host = host
+        self.timeout = timeout
+
+    def fetch_status_html(self) -> str:
+        response = requests.get(
+            f"https://{self.host}/status.php",
+            timeout=self.timeout,
+            verify=False,
+        )
+        response.raise_for_status()
+        return response.text

fastmile_parser/scraper.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from bs4 import BeautifulSoup, Comment, Tag
+
+from fastmile_parser.models import (
+    ApnInfo,
+    CaInfo,
+    CellSignal,
+    DeviceInfo,
+    InterfaceData,
+    LteInfo,
+    Snapshot,
+    SnapshotData,
+    TrafficValue,
+)
+
+
+def _text(tag: Tag) -> str:
+    return tag.get_text(strip=True)
+
+
+def _first_text(soup: BeautifulSoup, element_id: str) -> str:
+    tag = soup.find(id=element_id)
+    if tag is None:
+        raise ValueError(f"missing element: {element_id}")
+    return _text(tag)
+
+
+def _parse_int(value: str) -> int:
+    match = re.search(r"-?\d+", value)
+    if not match:
+        raise ValueError(f"expected integer in: {value!r}")
+    return int(match.group(0))
+
+
+def _parse_ip(value: str) -> Optional[str]:
+    value = value.strip()
+    return None if value in {"", "::"} else value
+
+
+def _parse_traffic(value: str) -> TrafficValue:
+    cleaned = value.strip().upper()
+    match = re.match(r"([0-9.]+)\s*([A-Z]+)", cleaned)
+    if not match:
+        raise ValueError(f"invalid traffic value: {value!r}")
+    amount = float(match.group(1))
+    unit = match.group(2)
+    if unit == "MB":
+        val_gb = amount / 1000
+    elif unit == "GB":
+        val_gb = amount
+    elif unit == "KB":
+        val_gb = amount / 1_000_000
+    else:
+        val_gb = amount
+    return TrafficValue(val=amount, unit=unit, val_gb=val_gb)
+
+
+def _find_comment_section(soup: BeautifulSoup, comment_text: str) -> Optional[Tag]:
+    comment = soup.find(string=lambda text: isinstance(text, Comment) and text.strip() == comment_text)
+    if comment is None:
+        return None
+    sibling = comment.find_next_sibling()
+    while sibling is not None and not isinstance(sibling, Tag):
+        sibling = sibling.find_next_sibling()
+    return sibling
+
+
+def _parse_apns(soup: BeautifulSoup) -> list[ApnInfo]:
+    section = _find_comment_section(soup, "APNs card")
+    if section is None:
+        return []
+    values = section.find_all("div", id=None)
+    if len(values) < 3:
+        return []
+    result: list[ApnInfo] = []
+    for index in range(2, len(values), 3):
+        if index + 2 >= len(values):
+            break
+        result.append(
+            ApnInfo(
+                name=_text(values[index]),
+                ipv4=_parse_ip(_text(values[index + 1])),
+                ipv6=_parse_ip(_text(values[index + 2])),
+            )
+        )
+    return result
+
+
+def _parse_cell_group(section: Tag, cell_type: Optional[str]) -> list[CellSignal]:
+    values = section.find_all(class_="name-of-value-in-card-bold")
+    result: list[CellSignal] = []
+    for index in range(0, len(values), 7):
+        chunk = values[index : index + 7]
+        if len(chunk) < 7:
+            break
+        result.append(
+            CellSignal(
+                pci=_parse_int(_text(chunk[0])),
+                earfcn=_parse_int(_text(chunk[1])),
+                cell_type=_text(chunk[2]) if cell_type is not None else None,
+                rsrp=_parse_int(_text(chunk[3])),
+                rsrq=_parse_int(_text(chunk[4])),
+                rssi=_parse_int(_text(chunk[5])),
+                sinr=_parse_int(_text(chunk[6])),
+            )
+        )
+    return result
+
+
+def _parse_available_cells(soup: BeautifulSoup) -> list[CellSignal]:
+    result: list[CellSignal] = []
+    index = 0
+    while True:
+        cell_id = soup.find(id=f"available-cell-id-{index}")
+        if cell_id is None:
+            break
+        result.append(
+            CellSignal(
+                pci=_parse_int(_text(cell_id)),
+                earfcn=_parse_int(_first_text(soup, f"available-earfcn-{index}")),
+                cell_type=None,
+                rsrp=_parse_int(_first_text(soup, f"rsrp-{index}")),
+                rsrq=_parse_int(_first_text(soup, f"rsrq-{index}")),
+                rssi=_parse_int(_first_text(soup, f"rssi-{index}")),
+                sinr=_parse_int(_first_text(soup, f"sinr-{index}")),
+            )
+        )
+        index += 1
+    return result
+
+
+def _parse_ca(soup: BeautifulSoup) -> CaInfo:
+    attached = soup.find(id="attached-cell-val")
+    if attached is None:
+        raise ValueError("missing attached-cell-val")
+    spans = attached.find_all("span")
+    if len(spans) < 3:
+        raise ValueError("missing carrier aggregation values")
+    enb = _parse_int(_text(spans[0]))
+    cid = _parse_int(_text(spans[1]))
+    primary_band = _parse_int(_text(spans[2]))
+
+    dl_text = _first_text(soup, "bandDL-val")
+    ul_text = _first_text(soup, "bandUL-val")
+    dl_bands = [primary_band]
+    ul_bands = [primary_band]
+    dl_match = re.findall(r"B(\d+)", dl_text)
+    ul_match = re.findall(r"B(\d+)", ul_text)
+    dl_bands.extend(int(value) for value in dl_match)
+    ul_bands.extend(int(value) for value in ul_match)
+    return CaInfo(enb=enb, cid=cid, dl_bands=dl_bands, ul_bands=ul_bands)
+
+
+def _parse_interface_data(soup: BeautifulSoup, name: str) -> InterfaceData:
+    section = soup.find(class_=name)
+    if section is None:
+        raise ValueError(f"missing traffic section: {name}")
+    bytes_values = section.find_all(class_="bytes")
+    if len(bytes_values) < 2:
+        raise ValueError(f"missing traffic values for: {name}")
+    return InterfaceData(
+        download=_parse_traffic(_text(bytes_values[0])),
+        upload=_parse_traffic(_text(bytes_values[1])),
+    )
+
+
+def parse_snapshot(html: str) -> Snapshot:
+    soup = BeautifulSoup(html, "html.parser")
+
+    device = DeviceInfo(
+        model=_first_text(soup, "model-value"),
+        software_version=_first_text(soup, "software-version-val"),
+        serial_number=_first_text(soup, "sn-value"),
+        imei=_first_text(soup, "imei-value"),
+        imsi=_first_text(soup, "imsi-name-value"),
+        mac=_first_text(soup, "eth-mac-value"),
+        lock_status=_first_text(soup, "lockStatus-name-value"),
+    )
+
+    data = SnapshotData(
+        eth=_parse_interface_data(soup, "Ethernet"),
+        lte=_parse_interface_data(soup, "LTE"),
+    )
+
+    primary_section = _find_comment_section(soup, "Primary Cell information card")
+    secondary_section = _find_comment_section(soup, "Secondary Cell information card")
+    available_section = _find_comment_section(soup, "Available cells grid (*x6)")
+
+    active: list[CellSignal] = []
+    if primary_section is not None:
+        active.extend(_parse_cell_group(primary_section, cell_type="primary"))
+    if secondary_section is not None:
+        active.extend(_parse_cell_group(secondary_section, cell_type="secondary"))
+
+    available: list[CellSignal] = []
+    if available_section is not None:
+        available = _parse_available_cells(soup)
+
+    lte = LteInfo(
+        ca=_parse_ca(soup),
+        active=active,
+        available=available,
+    )
+
+    apns = _parse_apns(soup)
+
+    return Snapshot(device=device, apns=apns, data=data, lte=lte)

fastmile_parser-0.1.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: fastmile-parser
+Version: 0.1.0
+Summary: Shared Nokia FastMile router snapshot parser
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32
+Requires-Dist: beautifulsoup4>=4.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# fastmile-parser
+
+Shared Nokia FastMile parser package.
+
+## What it does
+
+- fetches `https://<router>/status.php`
+- parses the status page into typed snapshot models
+- preserves the exact field set used by `fastmile-api`
+
+## Usage
+
+```python
+from fastmile_parser.router_client import RouterClient
+from fastmile_parser.scraper import parse_snapshot
+
+html = RouterClient("192.168.0.1").fetch_status_html()
+snapshot = parse_snapshot(html)
+```

fastmile_parser-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+fastmile_parser/__init__.py,sha256=VxBCVYLd6gnRyVxo0o-siDdVLZ5PO7AVUTIJtJjER6k,31
+fastmile_parser/models.py,sha256=chOatSKOO0n97muxHBRHmu4xziVU1qwOIJepsX-761U,1164
+fastmile_parser/router_client.py,sha256=imqjw85-fmLRcP-AI8TEQF5Cuwv3WJwFrGr4ycTST3Y,448
+fastmile_parser/scraper.py,sha256=UHhjssr2lU6EUB8H3dI-zt8_M-tOV61qv9FuFSSWyFM,6827
+fastmile_parser-0.1.0.dist-info/licenses/LICENSE,sha256=70g4uVM0kN3pmzCxDNLMvNWuRany6AUJC8GD_d9J8Yk,1066
+fastmile_parser-0.1.0.dist-info/METADATA,sha256=nvwVGuevQTLKlxYWzQqLBHx_mANqMHlvJP9xapHSmkQ,816
+fastmile_parser-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fastmile_parser-0.1.0.dist-info/top_level.txt,sha256=leYbsvvMEhTgEXsRXaj5GT5qHg9gswfpqgWbHS6UnLw,16
+fastmile_parser-0.1.0.dist-info/RECORD,,

fastmile_parser-0.1.0.dist-info/WHEEL

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

fastmile_parser-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AdrianKlm
+
+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.

fastmile_parser-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastmile_parser