pythonkuma 0.0.0rc1__tar.gz → 0.0.0rc3__tar.gz

{pythonkuma-0.0.0rc1 → pythonkuma-0.0.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonkuma
-Version: 0.0.0rc1
+Version: 0.0.0rc3
 Summary: Simple Python wrapper for Uptime Kuma
 Project-URL: Source, https://github.com/tr4nt0r/pythonkuma
 Author-email: Manfred Dennerlein Rodelo <manfred@dennerlein.name>, Jayakorn Karikan <jayakornk@gmail.com>
@@ -37,17 +37,16 @@ import aiohttp
 
 from pythonkuma import UptimeKuma
 
-URL = ""
-USERNAME = ""
-PASSWORD = ""
+URL = "https://uptime.exampe.com"
+API_KEY = "api_key"
 
 
 async def main():
 
     async with aiohttp.ClientSession() as session:
-        uptime_kuma = UptimeKuma(session, URL, USERNAME, PASSWORD)
-        response = await uptime_kuma.async_get_monitors()
-        print(response.data)
+        uptime_kuma = UptimeKuma(session, URL, API_KEY)
+        response = await uptime_kuma.metrics()
+        print(response)
 
 
 asyncio.run(main())

{pythonkuma-0.0.0rc1 → pythonkuma-0.0.0rc3}/README.md

@@ -16,17 +16,16 @@ import aiohttp
 
 from pythonkuma import UptimeKuma
 
-URL = ""
-USERNAME = ""
-PASSWORD = ""
+URL = "https://uptime.exampe.com"
+API_KEY = "api_key"
 
 
 async def main():
 
     async with aiohttp.ClientSession() as session:
-        uptime_kuma = UptimeKuma(session, URL, USERNAME, PASSWORD)
-        response = await uptime_kuma.async_get_monitors()
-        print(response.data)
+        uptime_kuma = UptimeKuma(session, URL, API_KEY)
+        response = await uptime_kuma.metrics()
+        print(response)
 
 
 asyncio.run(main())

{pythonkuma-0.0.0rc1 → pythonkuma-0.0.0rc3}/pythonkuma/__init__.py

@@ -5,15 +5,15 @@ from .exceptions import (
     UptimeKumaConnectionException,
     UptimeKumaException,
 )
-from .models import MonitorType, UptimeKumaApiResponse, UptimeKumaMonitor
+from .models import MonitorStatus, MonitorType, UptimeKumaMonitor
 from .uptimekuma import UptimeKuma
 
-__version__ = "0.0.0rc1"
+__version__ = "0.0.0rc3"
 
 __all__ = [
+    "MonitorStatus",
     "MonitorType",
     "UptimeKuma",
-    "UptimeKumaApiResponse",
     "UptimeKumaAuthenticationException",
     "UptimeKumaConnectionException",
     "UptimeKumaException",

pythonkuma-0.0.0rc3/pythonkuma/models.py

@@ -0,0 +1,77 @@
+"""Uptime Kuma models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum, StrEnum
+from typing import Self
+
+from mashumaro import DataClassDictMixin
+
+
+class MonitorStatus(IntEnum):
+    """Monitor states."""
+
+    DOWN = 0
+    UP = 1
+    PENDING = 2
+    MAINTENANCE = 3
+
+
+class MonitorType(StrEnum):
+    """Monitors type."""
+
+    HTTP = "http"
+    PORT = "port"
+    PING = "ping"
+    KEYWORD = "keyword"
+    DNS = "dns"
+    PUSH = "push"
+    STEAM = "steam"
+    MQTT = "mqtt"
+    SQL = "sqlserver"
+    JSON_QUERY = "json-query"
+    GROUP = "group"
+    DOCKER = "docker"
+    GRPC_KEYWORD = "grpc-keyword"
+    REAL_BROWSER = "real-browser"
+    GAMEDIG = "gamedig"
+    KAFKA_PRODUCER = "kafka-producer"
+    POSTGRES = "postgres"
+    MYSQL = "mysql"
+    MONGODB = "mongodb"
+    RADIUS = "radius"
+    REDIS = "redis"
+    TAILSCALE_PING = "tailscale-ping"
+    UNKNOWN = "unknown"
+
+    @classmethod
+    def _missing_(cls, _: object) -> Self:
+        """Handle new and unknown monitor types."""
+        return cls.UNKNOWN
+
+
+@dataclass
+class UptimeKumaBaseModel(DataClassDictMixin):
+    """UptimeKumaBaseModel."""
+
+
+@dataclass(kw_only=True)
+class UptimeKumaMonitor(UptimeKumaBaseModel):
+    """Monitor model for Uptime Kuma."""
+
+    monitor_cert_days_remaining: int
+    monitor_cert_is_valid: bool
+    monitor_hostname: str | None = field(
+        metadata={"deserialize": lambda v: None if v == "null" else v}
+    )
+    monitor_name: str
+    monitor_port: str | None = field(
+        metadata={"deserialize": lambda v: None if v == "null" else v}
+    )
+    monitor_response_time: int = 0
+    monitor_status: MonitorStatus
+    monitor_type: MonitorType = MonitorType.HTTP
+    monitor_url: str | None = field(
+        metadata={"deserialize": lambda v: None if v == "null" else v}
+    )

pythonkuma-0.0.0rc3/pythonkuma/uptimekuma.py

@@ -0,0 +1,76 @@
+"""Uptime Kuma client."""
+
+from http import HTTPStatus
+from typing import Any
+
+from aiohttp import (
+    BasicAuth,
+    ClientError,
+    ClientResponseError,
+    ClientSession,
+    ClientTimeout,
+)
+from prometheus_client.parser import text_string_to_metric_families
+from yarl import URL
+
+from .exceptions import UptimeKumaAuthenticationException, UptimeKumaConnectionException
+from .models import UptimeKumaMonitor
+
+
+class UptimeKuma:
+    """Uptime Kuma client."""
+
+    def __init__(
+        self,
+        session: ClientSession,
+        base_url: URL | str,
+        api_key: str | None = None,
+        timeout: float | None = None,
+    ) -> None:
+        """Initialize the Uptime Kuma client."""
+        self._base_url = base_url if isinstance(base_url, URL) else URL(base_url)
+
+        self._auth = BasicAuth("", api_key) if api_key else None
+
+        self._timeout = ClientTimeout(total=timeout or 10)
+        self._session = session
+
+    async def metrics(self) -> list[UptimeKumaMonitor]:
+        """Retrieve metrics from Uptime Kuma."""
+        url = self._base_url / "metrics"
+
+        try:
+            request = await self._session.get(
+                url, auth=self._auth, timeout=self._timeout
+            )
+            request.raise_for_status()
+        except ClientResponseError as e:
+            if e.status is HTTPStatus.UNAUTHORIZED:
+                msg = "Authentication failed for %s"
+                raise UptimeKumaAuthenticationException(msg, str(url)) from e
+            msg = "Request for %s failed with status code %s"
+            raise UptimeKumaConnectionException(msg, str(url), e.status) from e
+        except TimeoutError as e:
+            msg = "Request timeout for %s"
+            raise UptimeKumaConnectionException(msg, str(url)) from e
+        except ClientError as e:
+            raise UptimeKumaConnectionException from e
+        else:
+            parsed = text_string_to_metric_families(await request.text())
+
+            monitors: dict[str, dict[str, Any]] = {}
+            for metric in parsed:
+                if not metric.name.startswith("monitor"):
+                    continue
+                for sample in metric.samples:
+                    if not (monitor_name := sample.labels.get("monitor_name")):
+                        continue
+
+                    monitors.setdefault(monitor_name, sample.labels).update(
+                        {sample.name: sample.value}
+                    )
+
+            return {
+                key: UptimeKumaMonitor.from_dict(value)
+                for key, value in monitors.items()
+            }

pythonkuma-0.0.0rc1/pythonkuma/const.py

@@ -1,5 +0,0 @@
-"""Uptime Kuma constants."""
-
-from logging import Logger, getLogger
-
-LOGGER: Logger = getLogger(__package__)

pythonkuma-0.0.0rc1/pythonkuma/decorator.py

@@ -1,71 +0,0 @@
-"""Decorator for Uptime Kuma"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import aiohttp
-
-from . import exceptions
-from .const import LOGGER
-from .models import UptimeKumaApiResponse
-
-if TYPE_CHECKING:
-    from .uptimekuma import UptimeKuma
-
-
-def api_request(api_path: str, method: str = "GET"):
-    """Decorator for Uptime Kuma API request"""
-
-    def decorator(func):
-        """Decorator"""
-
-        async def wrapper(*args, **kwargs):
-            """Wrapper"""
-            client: UptimeKuma = args[0]
-            url = client._base_url / api_path
-            LOGGER.debug("Requesting %s", url.human_repr())
-            try:
-                request = await client._session.request(
-                    method=method,
-                    url=url,
-                    timeout=aiohttp.ClientTimeout(total=10),
-                    auth=aiohttp.BasicAuth(client._username, client._password),
-                )
-
-                if request.status != 200:
-                    raise exceptions.UptimeKumaConnectionException(
-                        f"Request for '{url}' failed with status code '{request.status}'"
-                    )
-
-                result = await request.text()
-            except aiohttp.ClientError as exception:
-                raise exceptions.UptimeKumaConnectionException(
-                    f"Request exception for '{url}' with - {exception}"
-                ) from exception
-
-            except TimeoutError:
-                raise exceptions.UptimeKumaConnectionException(f"Request timeout for '{url}'") from None
-
-            except exceptions.UptimeKumaConnectionException as exception:
-                raise exceptions.UptimeKumaConnectionException(exception) from exception
-
-            except exceptions.UptimeKumaException as exception:
-                raise exceptions.UptimeKumaException(exception) from exception
-
-            except (Exception, BaseException) as exception:
-                raise exceptions.UptimeKumaException(
-                    f"Unexpected exception for '{url}' with - {exception}"
-                ) from exception
-
-            LOGGER.debug("Requesting %s returned %s", url, result)
-
-            response = UptimeKumaApiResponse.from_prometheus(
-                {"monitors": result, "_api_path": api_path, "_method": method}
-            )
-
-            return response
-
-        return wrapper
-
-    return decorator

pythonkuma-0.0.0rc1/pythonkuma/models.py

@@ -1,101 +0,0 @@
-"""Uptime Kuma models"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import Any
-
-from prometheus_client.parser import text_string_to_metric_families as parser
-
-
-class MonitorType(StrEnum):
-    """Monitors type."""
-
-    HTTP = "http"
-    PORT = "port"
-    PING = "ping"
-    KEYWORD = "keyword"
-    DNS = "dns"
-    PUSH = "push"
-    STEAM = "steam"
-    MQTT = "mqtt"
-    SQL = "sqlserver"
-    JSON_QUERY = "json-query"
-    GROUP = "group"
-    DOCKER = "docker"
-    GRPC_KEYWORD = "grpc-keyword"
-    REAL_BROWSER = "real-browser"
-    GAMEDIG = "gamedig"
-    KAFKA_PRODUCER = "kafka-producer"
-    POSTGRES = "postgres"
-    MYSQL = "mysql"
-    MONGODB = "mongodb"
-    RADIUS = "radius"
-    REDIS = "redis"
-    TAILSCALE_PING = "tailscale-ping"
-
-
-class UptimeKumaBaseModel:
-    """UptimeKumaBaseModel."""
-
-
-@dataclass
-class UptimeKumaMonitor(UptimeKumaBaseModel):
-    """Monitor model for Uptime Kuma."""
-
-    monitor_cert_days_remaining: float = 0
-    monitor_cert_is_valid: float = 0
-    monitor_hostname: str = ""
-    monitor_name: str = ""
-    monitor_port: str = ""
-    monitor_response_time: float = 0
-    monitor_status: float = 0
-    monitor_type: MonitorType = MonitorType.HTTP
-    monitor_url: str = ""
-
-    @staticmethod
-    def from_dict(data: dict[str, Any]) -> UptimeKumaMonitor:
-        """Generate object from json."""
-        obj: dict[str, Any] = {}
-        for key, value in data.items():
-            if hasattr(UptimeKumaMonitor, key):
-                obj[key] = MonitorType(value) if key == "monitor_type" else value
-
-        return UptimeKumaMonitor(**obj)
-
-
-@dataclass
-class UptimeKumaApiResponse(UptimeKumaBaseModel):
-    """API response model for Uptime Kuma."""
-
-    _method: str | None = None
-    _api_path: str | None = None
-    data: list[UptimeKumaMonitor] | None = None
-
-    @staticmethod
-    def from_prometheus(data: dict[str, Any]) -> UptimeKumaApiResponse:
-        """Generate object from json."""
-        obj: dict[str, Any] = {}
-        monitors = []
-
-        for key, value in data.items():
-            if hasattr(UptimeKumaApiResponse, key):
-                obj[key] = value
-
-        parsed = parser(data["monitors"])
-        for family in parsed:
-            for sample in family.samples:
-                if sample.name.startswith("monitor"):
-                    existed = next(
-                        (i for i, x in enumerate(monitors) if x["monitor_name"] == sample.labels["monitor_name"]),
-                        None,
-                    )
-                    if existed is None:
-                        temp = {**sample.labels, sample.name: sample.value}
-                        monitors.append(temp)
-                    else:
-                        monitors[existed][sample.name] = sample.value
-        obj["data"] = [UptimeKumaMonitor.from_dict(monitor) for monitor in monitors]
-
-        return UptimeKumaApiResponse(**obj)

pythonkuma-0.0.0rc1/pythonkuma/uptimekuma.py

@@ -1,23 +0,0 @@
-"""Uptime Kuma client."""
-
-from aiohttp import ClientSession
-from yarl import URL
-
-from .decorator import api_request
-from .models import UptimeKumaApiResponse
-
-
-class UptimeKuma:
-    """This class is used to get information from Uptime Kuma."""
-
-    def __init__(self, session: ClientSession, base_url: URL | str, username: str, password: str) -> None:
-        """Initialize"""
-        self.monitors = []
-        self._base_url = base_url if isinstance(base_url, URL) else URL(base_url)
-        self._username = username
-        self._password = password
-        self._session: ClientSession = session
-
-    @api_request("metrics")
-    async def async_get_monitors(self, **kwargs) -> UptimeKumaApiResponse:
-        """Get monitors from API."""