hardpy 0.12.0__tar.gz → 0.13.0__tar.gz

{hardpy-0.12.0 → hardpy-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hardpy
-Version: 0.12.0
+Version: 0.13.0
 Summary: HardPy library for device testing
 Project-URL: Homepage, https://github.com/everypinio/hardpy/
 Project-URL: Documentation, https://everypinio.github.io/hardpy/
@@ -34,6 +34,7 @@ Requires-Dist: py-machineid~=0.6.0
 Requires-Dist: pycouchdb<2,>=1.14.2
 Requires-Dist: pydantic<3,>=2.4.0
 Requires-Dist: pytest<9,>=7
+Requires-Dist: qrcode>=8
 Requires-Dist: requests-oauth2client<2,>=1.5.0
 Requires-Dist: requests-oauthlib<3,>=2.0.0
 Requires-Dist: requests<3,>=2.30.0

{hardpy-0.12.0 → hardpy-0.13.0}/hardpy/cli/cli.py

@@ -227,12 +227,13 @@ def sc_login(
         address (str): StandCloud address
         check (bool): Check StandCloud connection
     """
+    try:
+        sc_connector = StandCloudConnector(address)
+    except StandCloudError as exc:
+        print(str(exc))
+        sys.exit()
+
     if check:
-        try:
-            sc_connector = StandCloudConnector(address)
-        except StandCloudError as exc:
-            print(str(exc))
-            sys.exit()
         try:
             sc_connector.healthcheck()
         except StandCloudError:
@@ -240,16 +241,20 @@ def sc_login(
             sys.exit()
         print("StandCloud connection success")
     else:
-        auth_login(address)
+        auth_login(sc_connector)
 
 
 @cli.command()
-def sc_logout() -> None:
-    """Logout HardPy from all StandCloud accounts."""
-    if auth_logout():
-        print("HardPy logout success")
+def sc_logout(address: Annotated[str, typer.Argument()]) -> None:
+    """Logout HardPy from StandCloud account.
+
+    Args:
+        address (str): StandCloud address
+    """
+    if auth_logout(address):
+        print(f"HardPy logout success from {address}")
     else:
-        print("HardPy logout failed")
+        print(f"HardPy logout failed from {address}")
 
 
 def _get_config(tests_dir: str | None = None) -> HardpyConfig:

hardpy-0.13.0/hardpy/common/stand_cloud/connector.py

@@ -0,0 +1,228 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from http import HTTPStatus
+from logging import getLogger
+from time import sleep
+from typing import TYPE_CHECKING
+
+import requests
+from oauthlib.oauth2.rfc6749.errors import OAuth2Error
+from requests.exceptions import RequestException
+from requests_oauth2client import ApiClient, BearerToken
+from requests_oauth2client.tokens import ExpiredAccessToken
+
+from hardpy.common.stand_cloud.exception import StandCloudError
+from hardpy.common.stand_cloud.oauth2 import OAuth2
+from hardpy.common.stand_cloud.token_manager import TokenManager
+from hardpy.common.stand_cloud.utils import StandCloudAPIMode, StandCloudAddr
+
+if TYPE_CHECKING:
+    from requests import Response
+
+
+class StandCloudConnector:
+    """StandCloud API connector."""
+
+    def __init__(
+        self,
+        addr: str,
+        api_mode: StandCloudAPIMode = StandCloudAPIMode.HARDPY,
+        api_version: int = 1,
+    ) -> None:
+        """Create StandCloud API connector.
+
+        Args:
+            addr (str): StandCloud service name.
+            api_mode (StandCloudAPIMode): StandCloud API mode,
+                hardpy for test stand, integration for third-party service.
+                Default: StandCloudAPIMode.HARDPY.
+            api_version (int): StandCloud API version.
+                Default: 1.
+        """
+        https_prefix = "https://"
+        auth_addr = addr + "/auth"
+
+        self._addr: StandCloudAddr = StandCloudAddr(
+            domain=addr,
+            api=https_prefix + addr + f"/{api_mode.value}/api/v{api_version}",
+            token=https_prefix + auth_addr + "/api/oidc/token",
+            auth=https_prefix + auth_addr + "/api/oidc/authorization",
+            device=https_prefix + auth_addr + "/api/oidc/device-authorization",
+        )
+
+        self._client_id = "hardpy-report-uploader"
+        self._verify_ssl = not __debug__
+        self._token_manager = TokenManager(self._addr.domain)
+        self._token: BearerToken = self.get_access_token()
+        self._log = getLogger(__name__)
+
+    @property
+    def addr(self) -> str:
+        """Get StandCloud service name."""
+        return self._addr.domain
+
+    @property
+    def api_url(self) -> str:
+        """Get StandCloud API URL."""
+        return self._addr.api
+
+    def update_token(self, token: BearerToken) -> None:
+        """Update access token.
+
+        Args:
+            token (BearerToken): access token.
+        """
+        self._token = token
+
+    def is_refresh_token_valid(self) -> bool:
+        """Check if token is valid.
+
+        Returns:
+            bool: True if token is valid, False otherwise.
+        """
+        try:
+            OAuth2(
+                sc_addr=self._addr,
+                client_id=self._client_id,
+                token=self._token,
+                token_manager=self._token_manager,
+                verify_ssl=self._verify_ssl,
+            )
+        except OAuth2Error:
+            return False
+        return True
+
+
+    def get_access_token(self) -> BearerToken | None:
+        """Read access token from token store.
+
+        Returns:
+            BearerToken: access token
+        """
+        try:
+            return self._token_manager.read_access_token()
+        except Exception:  # noqa: BLE001
+            return None
+
+    def get_verification_url(self) -> dict:
+        """Get StandCloud verification URL.
+
+        Returns:
+            dict: verification URL
+        """
+        req = requests.post(
+            self._addr.device,
+            data={
+                "client_id": self._client_id,
+                "scope": "offline_access authelia.bearer.authz",
+                "audience": self._addr.api,
+            },
+            verify=self._verify_ssl,
+            timeout=10,
+        )
+        if req.status_code != HTTPStatus.OK:
+            raise StandCloudError(req.text)
+        return json.loads(req.content)
+
+    def get_api(self, endpoint: str) -> ApiClient:
+        """Get StandCloud API client.
+
+        Args:
+            endpoint (str): endpoint address.
+
+        Returns:
+            ApiClient: API clinet
+        """
+        return self._get_api(endpoint)
+
+    def healthcheck(self) -> Response:
+        """Healthcheck of StandCloud API.
+
+        Returns:
+            Response: healthcheck response
+
+        Raises:
+            StandCloudError: if StandCloud is unavailable
+        """
+        api = self._get_api("healthcheck")
+
+        try:
+            resp = api.get(verify=self._verify_ssl)
+        except ExpiredAccessToken as exc:
+            raise StandCloudError(str(exc)) from exc
+        except OAuth2Error as exc:
+            raise StandCloudError(exc.description) from exc
+        except RequestException as exc:
+            raise StandCloudError(exc.strerror) from exc  # type: ignore
+
+        return resp
+
+    def wait_verification(
+        self,
+        response: dict,
+        waiting_time_m: int = 5,
+    ) -> BearerToken | None:
+        """Wait StandCloud verification.
+
+        Args:
+            response (dict): verification response
+            waiting_time_m (int): authorization waiting time in minutes
+
+        Returns:
+            BearerToken: access token
+        """
+        interval = response["interval"]
+        start_time = datetime.now(tz=timezone.utc)
+        device_code = response["device_code"]
+        while True:
+            sleep(interval)
+
+            req = requests.post(
+                self._addr.token,
+                data={
+                    "client_id": self._client_id,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                    "device_code": device_code,
+                },
+                verify=self._verify_ssl,
+                timeout=interval,
+            )
+            response = json.loads(req.content)
+
+            if "error" in response:
+                current_time = datetime.now(tz=timezone.utc)
+                if current_time >= start_time + timedelta(minutes=waiting_time_m):
+                    return None
+                continue
+
+            if "access_token" in response and "refresh_token" in response:
+                new_token = BearerToken(**response)
+
+                if "expires_at" not in response and new_token.expires_at:
+                    response["expires_at"] = new_token.expires_at.timestamp()
+                self._token_manager.save_token_info(response)
+                return new_token
+
+    def _get_api(self, endpoint: str) -> ApiClient:
+        if self._token is None:
+            msg = (
+                f"Access token to {self._addr.domain} is not set."
+                f"Login to {self._addr.domain} first"
+            )
+            raise StandCloudError(msg)
+        try:
+            auth = OAuth2(
+                sc_addr=self._addr,
+                client_id=self._client_id,
+                token=self._token,
+                token_manager=self._token_manager,
+                verify_ssl=self._verify_ssl,
+            )
+        except OAuth2Error as exc:
+            raise StandCloudError(exc.description) from exc
+        session = auth.session
+        return ApiClient(f"{self._addr.api}/{endpoint}", session=session, timeout=10)

hardpy-0.13.0/hardpy/common/stand_cloud/oauth2.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2025 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import annotations
+
+from datetime import timedelta
+from typing import TYPE_CHECKING
+
+from requests.auth import AuthBase
+from requests_oauth2client import BearerToken
+from requests_oauthlib import OAuth2Session
+
+if TYPE_CHECKING:
+    from requests import PreparedRequest
+    from requests_oauth2client import ApiClient
+
+    from hardpy.common.stand_cloud.token_manager import TokenManager
+    from hardpy.common.stand_cloud.utils import StandCloudAddr
+
+
+class OAuth2(AuthBase):
+    """Authorize HardPy using the device flow of OAuth 2.0."""
+
+    def __init__(
+        self,
+        sc_addr: StandCloudAddr,
+        client_id: str,
+        token: BearerToken,
+        token_manager: TokenManager,
+        verify_ssl: bool = True,
+    ) -> None:
+        self._sc_addr = sc_addr
+        self._client_id = client_id
+        self._verify_ssl = verify_ssl
+        self._token_manager = token_manager
+
+        self._token = self._check_token(token)
+
+    def __call__(self, req: PreparedRequest) -> PreparedRequest:
+        """Append an OAuth 2 token to the request.
+
+        Note that currently HTTPS is required for all requests. There may be
+        a token type that allows for plain HTTP in the future and then this
+        should be updated to allow plain HTTP on a white list basis.
+        """
+        req.headers[self._token.AUTHORIZATION_HEADER] = (  # type: ignore
+            self._token.authorization_header()
+        )
+        return req
+
+    def _check_token(self, token: BearerToken) -> ApiClient:
+        """Check token in OAuth2 session and refresh it if needed.
+
+        Args:
+            token (BearerToken): bearer token to check
+
+        Returns:
+            ApiClient: refreshed token
+        """
+        refresh_url = self._sc_addr.token
+
+        self.session = OAuth2Session(
+            client_id=self._client_id,
+            token=token.as_dict(),
+            token_updater=self._token_manager.save_token_info,
+        )
+
+        is_need_refresh = False
+        early_refresh = timedelta(seconds=60)
+
+        if token.expires_in and token.expires_in < early_refresh.seconds:
+            is_need_refresh = True
+        if token.access_token is None:
+            is_need_refresh = True
+
+        if is_need_refresh:
+            extra = {"client_id": self._client_id, "audience": self._sc_addr.api}
+            ret = self.session.refresh_token(
+                token_url=refresh_url,
+                refresh_token=self._token_manager.read_refresh_token(),
+                verify=self._verify_ssl,
+                **extra,
+            )
+
+            self._token_manager.save_token_info(ret)
+            return BearerToken(**ret)
+
+        return token

hardpy-0.13.0/hardpy/common/stand_cloud/registration.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2025 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import annotations
+
+from datetime import timedelta
+from io import StringIO
+from typing import TYPE_CHECKING
+
+from oauthlib.oauth2.rfc6749.errors import OAuth2Error
+from qrcode import QRCode
+from requests.exceptions import ConnectionError as RequestConnectionError, HTTPError
+from requests_oauth2client.tokens import ExpiredAccessToken
+
+from hardpy.common.stand_cloud.exception import StandCloudError
+from hardpy.common.stand_cloud.token_manager import TokenManager
+
+if TYPE_CHECKING:
+    from hardpy.common.stand_cloud.connector import StandCloudConnector
+
+
+def login(sc_connector: StandCloudConnector) -> None:
+    """Login HardPy in StandCloud.
+
+    Args:
+        sc_connector (StandCloudConnector): StandCloud connector
+    """
+    token = sc_connector.get_access_token()
+    if token is None or sc_connector.is_refresh_token_valid() is False:
+        try:
+            response = sc_connector.get_verification_url()
+        except (RequestConnectionError, StandCloudError) as e:
+            print(f"Connection error to StandCloud: {sc_connector.addr}. \nError: {e}")
+            return
+        url = response["verification_uri_complete"]
+        _print_user_action_request(url)
+        token = sc_connector.wait_verification(response)
+
+    sc_connector.update_token(token)
+
+    try:
+        sc_connector.healthcheck()
+    except ExpiredAccessToken as e:
+        time_diff = timedelta(seconds=abs(e.args[0].expires_in))
+        print(f"API access error: token is expired for {time_diff}")
+    except OAuth2Error as e:
+        print(e.description)
+    except HTTPError as e:
+        print(e)
+    else:
+        print(f"HardPy login to {sc_connector.addr} success")
+
+
+def logout(addr: str) -> bool:
+    """Logout HardPy from StandCloud.
+
+    Args:
+        addr (str): StandCloud address
+
+    Returns:
+        bool: True if successful else False
+    """
+    token_manager = TokenManager(addr)
+    return token_manager.remove_token()
+
+def _print_user_action_request(url_complete: str) -> None:
+    qr = QRCode()
+    qr.add_data(url_complete)
+    f = StringIO()
+    qr.print_ascii(out=f)
+    f.seek(0)
+
+    print(f.read())
+    print("Scan the QR code or, using a browser on another device, visit:")
+    print(url_complete, end="\n\n")

hardpy-0.13.0/hardpy/common/stand_cloud/token_manager.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2025 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import suppress
+from copy import deepcopy
+from datetime import datetime, timezone
+from platform import system
+from typing import TYPE_CHECKING
+
+from keyring import delete_password, get_credential
+from keyring.core import load_keyring
+from keyring.errors import KeyringError
+from requests_oauth2client import BearerToken
+
+if TYPE_CHECKING:
+    from keyring.backend import KeyringBackend
+
+
+class TokenManager:
+    """Token manager.
+
+    Manage token in keyring storage.
+    """
+
+    def __init__(self, service_name: str) -> None:
+        self._service_name = f"HardPy_{service_name}"
+
+    def remove_token(self) -> bool:
+        """Remove token from keyring storage.
+
+        Returns:
+            bool: True if successful else False
+        """
+        try:
+            while cred := get_credential(self._service_name, None):
+                delete_password(self._service_name, cred.username)
+        except KeyringError:
+            return False
+        # TODO(xorialexandrov): fix keyring clearing
+        # Windows does not clear refresh token by itself
+        if system() == "Windows":
+            storage_keyring, _ = self._get_store()
+            with suppress(KeyringError):
+                storage_keyring.delete_password(self._service_name, "refresh_token")
+        return True
+
+    def save_token_info(self, token: BearerToken | dict) -> None:
+        """Save token to keyring storage.
+
+        Args:
+            token (BearerToken | dict): token
+        """
+        # fmt: off
+        storage_keyring, mem_keyring = self._get_store()
+        storage_keyring.set_password(self._service_name, "refresh_token", token["refresh_token"])  # noqa: E501
+
+        token_info = deepcopy(token)
+        token_info.pop("expires_in")
+        token_info.pop("refresh_token")
+
+        try:
+            mem_keyring.set_password(self._service_name, "access_token", json.dumps(token_info))  # noqa: E501
+        except KeyringError as e:
+            print(e)  # noqa: T201
+            sys.exit(1)
+        # fmt: on
+
+    def read_access_token(self) -> BearerToken:
+        """Read access token from token store.
+
+        Returns:
+            BearerToken: access token
+        """
+        _, mem_keyring = self._get_store()
+        token_info = mem_keyring.get_password(self._service_name, "access_token")
+        secret = self._add_expires_in(json.loads(token_info))  # type: ignore
+        return BearerToken(**secret)
+
+    def read_refresh_token(self) -> str | None:
+        """Read refresh token from token store.
+
+        Returns:
+            str | None: refresh token
+        """
+        storage_keyring, _ = self._get_store()
+        service_name = self._service_name
+        return storage_keyring.get_password(service_name, "refresh_token")
+
+    def _get_store(self) -> tuple[KeyringBackend, KeyringBackend]:
+        """Get token store.
+
+        Returns:
+            tuple[KeyringBackend, KeyringBackend]: token store
+        """
+        if system() == "Linux":
+            storage_keyring = load_keyring("keyring.backends.SecretService.Keyring")
+        elif system() == "Windows":
+            storage_keyring = load_keyring("keyring.backends.Windows.WinVaultKeyring")
+        # TODO(xorialexandrov): add memory keyring or other store
+        mem_keyring = storage_keyring
+
+        return storage_keyring, mem_keyring
+
+    def _add_expires_in(self, secret: dict) -> dict:
+        if "expires_at" in secret:
+            expires_at = secret["expires_at"]
+        elif "id_token" in secret and "exp" in secret["id_token"]:
+            expires_at = secret["id_token"]["exp"]
+        expires_at_datetime = datetime.fromtimestamp(expires_at, timezone.utc)
+
+        expires_in_datetime = expires_at_datetime - datetime.now(timezone.utc)
+        expires_in = int(expires_in_datetime.total_seconds())
+
+        secret["expires_in"] = expires_in
+
+        return secret

hardpy-0.13.0/hardpy/common/stand_cloud/utils.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+from __future__ import annotations
+
+from enum import Enum
+from typing import NamedTuple
+
+
+class StandCloudAddr(NamedTuple):
+    """StandCloud address.
+
+    domain: StandCloud address
+    api: API address
+    token: token address
+    auth: auth address
+    device: device-authorization address
+    """
+
+    domain: str
+    api: str
+    token: str
+    auth: str
+    device: str
+
+
+class StandCloudAPIMode(str, Enum):
+    """StandCloud API mode.
+
+    HARDPY for test stand, integration for third-party service.
+    """
+
+    HARDPY = "hardpy"
+    INTEGRATION = "integration"

hardpy-0.12.0/hardpy/hardpy_panel/frontend/dist/assets/allPaths-B26356fZ.js → hardpy-0.13.0/hardpy/hardpy_panel/frontend/dist/assets/allPaths-Cg7WZDXy.js

@@ -1 +1 @@
-import{I as n}from"./index-xb4M2ucX.js";import{I as e}from"./index-BMEat_ws.js";import{p as r,I as s}from"./index-Bl_IX0Up.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};
+import{I as n}from"./index-xb4M2ucX.js";import{I as e}from"./index-BMEat_ws.js";import{p as r,I as s}from"./index-De5CJ3kt.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};

hardpy-0.12.0/hardpy/hardpy_panel/frontend/dist/assets/allPathsLoader-0BeGWuiy.js → hardpy-0.13.0/hardpy/hardpy_panel/frontend/dist/assets/allPathsLoader-C79wUwqR.js

@@ -1,2 +1,2 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-B26356fZ.js","assets/index-xb4M2ucX.js","assets/index-BMEat_ws.js","assets/index-Bl_IX0Up.js","assets/index-BwCQzehg.css"])))=>i.map(i=>d[i]);
-import{_ as o,a as n,b as i}from"./index-Bl_IX0Up.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-B26356fZ.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-Cg7WZDXy.js","assets/index-xb4M2ucX.js","assets/index-BMEat_ws.js","assets/index-De5CJ3kt.js","assets/index-BwCQzehg.css"])))=>i.map(i=>d[i]);
+import{_ as o,a as n,b as i}from"./index-De5CJ3kt.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-Cg7WZDXy.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};