hardpy 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

hardpy/__init__.py

@@ -1,6 +1,7 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
+from hardpy.common.stand_cloud import StandCloudError
 from hardpy.pytest_hardpy.pytest_call import (
     clear_operator_message,
     get_current_attempt,
@@ -19,7 +20,7 @@ from hardpy.pytest_hardpy.pytest_call import (
     set_stand_location,
     set_stand_name,
 )
-from hardpy.pytest_hardpy.result import CouchdbLoader
+from hardpy.pytest_hardpy.result import CouchdbLoader, StandCloudLoader
 from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
 from hardpy.pytest_hardpy.utils import (
     BaseWidget,
@@ -51,6 +52,8 @@ __all__ = [
     "MultistepWidget",
     "NumericInputWidget",
     "RadiobuttonWidget",
+    "StandCloudError",
+    "StandCloudLoader",
     "StepWidget",
     "TextInputWidget",
     "clear_operator_message",

hardpy/cli/cli.py

@@ -11,6 +11,18 @@ from uvicorn import run as uvicorn_run
 
 from hardpy.cli.template import TemplateGenerator
 from hardpy.common.config import ConfigManager
+from hardpy.common.stand_cloud import (
+    StandCloudConnector,
+    StandCloudError,
+    login as auth_login,
+    logout as auth_logout,
+)
+
+if __debug__:
+    from urllib3 import disable_warnings
+    from urllib3.exceptions import InsecureRequestWarning
+
+    disable_warnings(InsecureRequestWarning)
 
 cli = typer.Typer(add_completion=False)
 default_config = ConfigManager().get_config()
@@ -18,43 +30,51 @@ default_config = ConfigManager().get_config()
 
 @cli.command()
 def init(  # noqa: PLR0913
-    tests_dir: Annotated[Optional[str], typer.Argument()] = None,  # noqa: UP007
+    tests_dir: Annotated[Optional[str], typer.Argument()] = None,
     create_database: bool = typer.Option(
-        True,
+        default=True,
         help="Create CouchDB database.",
     ),
     database_user: str = typer.Option(
-        default_config.database.user,
+        default=default_config.database.user,
         help="Specify a database user.",
     ),
     database_password: str = typer.Option(
-        default_config.database.password,
+        default=default_config.database.password,
         help="Specify a database user password.",
     ),
     database_host: str = typer.Option(
-        default_config.database.host,
+        default=default_config.database.host,
         help="Specify a database host.",
     ),
     database_port: int = typer.Option(
-        default_config.database.port,
+        default=default_config.database.port,
         help="Specify a database port.",
     ),
     frontend_host: str = typer.Option(
-        default_config.frontend.host,
+        default=default_config.frontend.host,
         help="Specify a frontend host.",
     ),
     frontend_port: int = typer.Option(
-        default_config.frontend.port,
+        default=default_config.frontend.port,
         help="Specify a frontend port.",
     ),
     socket_host: str = typer.Option(
-        default_config.socket.host,
+        default=default_config.socket.host,
         help="Specify a socket host.",
     ),
     socket_port: int = typer.Option(
-        default_config.socket.port,
+        default=default_config.socket.port,
         help="Specify a socket port.",
     ),
+    sc_address: str = typer.Option(
+        default="",
+        help="Specify a StandCloud address.",
+    ),
+    sc_connection_only: bool = typer.Option(
+        default=False,
+        help="Check StandCloud service availability before start.",
+    ),
 ) -> None:
     """Initialize HardPy tests directory.
 
@@ -69,6 +89,8 @@ def init(  # noqa: PLR0913
         frontend_port (int): Panel operator port
         socket_host (str): Socket host
         socket_port (int): Socket port
+        sc_address (str): StandCloud address
+        sc_connection_only (bool): Flag to check StandCloud service availability
     """
     _tests_dir = tests_dir if tests_dir else default_config.tests_dir
     ConfigManager().init_config(
@@ -81,6 +103,8 @@ def init(  # noqa: PLR0913
         frontend_port=frontend_port,
         socket_host=socket_host,
         socket_port=socket_port,
+        sc_address=sc_address,
+        sc_connection_only=sc_connection_only,
     )
     # create tests directory
     dir_path = Path(Path.cwd() / _tests_dir)
@@ -116,7 +140,7 @@ def init(  # noqa: PLR0913
 
 
 @cli.command()
-def run(tests_dir: Annotated[Optional[str], typer.Argument()] = None) -> None:  # noqa: UP007
+def run(tests_dir: Annotated[Optional[str], typer.Argument()] = None) -> None:
     """Run HardPy server.
 
     Args:
@@ -140,5 +164,48 @@ def run(tests_dir: Annotated[Optional[str], typer.Argument()] = None) -> None:
     )
 
 
+@cli.command()
+def sc_login(
+    address: Annotated[str, typer.Argument()],
+    check: bool = typer.Option(
+        False,
+        help="Check StandCloud connection.",
+    ),
+) -> None:
+    """Login HardPy in StandCloud.
+
+    The command opens an authentication and authorization portal of StandCloud
+    where you will be requested for your credentials and consents to authorize
+    HardPy to upload test reports from your identity.
+
+    Args:
+        address (str): StandCloud address
+        check (bool): Check StandCloud connection
+    """
+    if check:
+        try:
+            sc_connector = StandCloudConnector(address)
+        except StandCloudError as exc:
+            print(str(exc))
+            sys.exit()
+        try:
+            sc_connector.healthcheck()
+        except StandCloudError:
+            print("StandCloud connection failed")
+            sys.exit()
+        print("StandCloud connection success")
+    else:
+        auth_login(address)
+
+
+@cli.command()
+def sc_logout() -> None:
+    """Logout HardPy from all StandCloud accounts."""
+    if auth_logout():
+        print("HardPy logout success")
+    else:
+        print("HardPy logout failed")
+
+
 if __name__ == "__main__":
     cli()

hardpy/common/config.py

@@ -50,6 +50,13 @@ class SocketConfig(BaseModel):
     host: str = "localhost"
     port: int = 6525
 
+class StandCloudConfig(BaseModel):
+    """StandCloud configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    address: str = ""
+    connection_only: bool = False
 
 class HardpyConfig(BaseModel):
     """HardPy configuration."""
@@ -61,6 +68,7 @@ class HardpyConfig(BaseModel):
     database: DatabaseConfig = DatabaseConfig()
     frontend: FrontendConfig = FrontendConfig()
     socket: SocketConfig = SocketConfig()
+    stand_cloud: StandCloudConfig = StandCloudConfig()
 
 
 class ConfigManager:
@@ -81,6 +89,8 @@ class ConfigManager:
         frontend_port: int,
         socket_host: str,
         socket_port: int,
+        sc_address: str = "",
+        sc_connection_only: bool = False,
     ) -> None:
         """Initialize HardPy configuration.
 
@@ -94,6 +104,8 @@ class ConfigManager:
             frontend_port (int): Operator panel port.
             socket_host (str): Socket host.
             socket_port (int): Socket port.
+            sc_address (str): StandCloud address.
+            sc_connection_only (bool): StandCloud check availability.
         """
         cls.obj.tests_dir = str(tests_dir)
         cls.obj.database.user = database_user
@@ -104,6 +116,8 @@ class ConfigManager:
         cls.obj.frontend.port = frontend_port
         cls.obj.socket.host = socket_host
         cls.obj.socket.port = socket_port
+        cls.obj.stand_cloud.address = sc_address
+        cls.obj.stand_cloud.connection_only = sc_connection_only
 
     @classmethod
     def create_config(cls, parent_dir: Path) -> None:
@@ -112,6 +126,8 @@ class ConfigManager:
         Args:
             parent_dir (Path): Configuration file parent directory.
         """
+        if not cls.obj.stand_cloud.address:
+            del cls.obj.stand_cloud
         config_str = tomli_w.dumps(cls.obj.model_dump())
         with Path.open(parent_dir / "hardpy.toml", "w") as file:
             file.write(config_str)

hardpy/common/stand_cloud/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from hardpy.common.stand_cloud.connector import StandCloudConnector
+from hardpy.common.stand_cloud.exception import StandCloudError
+from hardpy.common.stand_cloud.registration import login, logout
+
+__all__ = [
+    "StandCloudConnector",
+    "StandCloudError",
+    "login",
+    "logout",
+]

hardpy/common/stand_cloud/connector.py

@@ -0,0 +1,227 @@
+# 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 logging import getLogger
+from typing import TYPE_CHECKING, NamedTuple
+
+from oauthlib.oauth2.rfc6749.errors import (
+    InvalidGrantError,
+    MissingTokenError,
+    TokenExpiredError,
+)
+from requests.exceptions import (
+    ConnectionError as RequestConnectionError,
+    HTTPError,
+    InvalidURL,
+)
+from requests_oauth2client import ApiClient, BearerToken
+from requests_oauth2client.tokens import ExpiredAccessToken
+from requests_oauthlib import OAuth2Session
+
+from hardpy.common.stand_cloud.exception import StandCloudError
+from hardpy.common.stand_cloud.token_storage import get_token_store
+
+if TYPE_CHECKING:
+    from requests import Response
+
+
+class StandCloudURL(NamedTuple):
+    """URL.
+
+    api: API address
+    token: token address
+    par: pushed-authorization-request address
+    auth: auth address
+    """
+
+    api: str
+    token: str
+    par: str
+    auth: str
+
+class StandCloudConnector:
+    """StandCloud API connector."""
+
+    def __init__(
+        self,
+        addr: str,
+    ) -> None:
+        """Create StandCLoud loader.
+
+        Args:
+            addr (str | None, optional): StandCloud address.
+            The option only for development and debug. Defaults to True.
+        """
+        https_prefix = "https://"
+        auth_addr = addr + "/auth"
+
+        self._url: StandCloudURL = StandCloudURL(
+            api=https_prefix + addr + self._get_service_name(addr) + "/api/v1",
+            token=https_prefix + auth_addr + "/api/oidc/token",
+            par=https_prefix + auth_addr + "/api/oidc/pushed-authorization-request",
+            auth=https_prefix + auth_addr + "/api/oidc/authorization",
+        )
+
+        self._verify_ssl = not __debug__
+        self._log = getLogger(__name__)
+
+    @property
+    def url(self) -> StandCloudURL:
+        """Get StandCloud URL."""
+        return self._url
+
+    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))
+        except TokenExpiredError as exc:
+            raise StandCloudError(exc.description)
+        except InvalidGrantError as exc:
+            raise StandCloudError(exc.description)
+        except HTTPError as exc:
+            raise StandCloudError(exc.strerror)  # type: ignore
+
+        return resp
+
+    def _token_update(self, token: BearerToken) -> None:
+        storage_keyring, mem_keyring = get_token_store()
+
+        _access_token = "access_token"  # noqa: S105
+        _expires_at = "expires_at"
+        _refresh_token = "refresh_token"  # noqa: S105
+        _hardpy = "HardPy"
+
+        storage_keyring.set_password(_hardpy, _refresh_token, token[_refresh_token])
+        mem_keyring.set_password(_hardpy, _access_token, token[_access_token])
+
+        token_data = {
+            _access_token: token[_access_token],
+            _expires_at: token[_expires_at],
+        }
+
+        mem_keyring.set_password(_hardpy, _access_token, json.dumps(token_data))
+
+    def _get_expires_in(self, expires_at: float | None) -> int:
+        if expires_at is None:
+            return -1
+        expires_at_datetime = datetime.fromtimestamp(expires_at, timezone.utc)
+
+        now_datetime = datetime.now(timezone.utc)
+
+        expires_in_datetime = expires_at_datetime - now_datetime
+        return int(expires_in_datetime.total_seconds())
+
+    def _get_access_token_info(self) -> tuple[str | None, float | None]:
+        _, mem_keyring = get_token_store()
+
+        _access_token = "access_token"  # noqa: S105
+        _expires_at = "expires_at"
+
+        token_info = mem_keyring.get_password("HardPy", _access_token)
+        if token_info is None:
+            return None, None
+        token_dict = json.loads(token_info)
+        access_token = token_dict[_access_token]
+        expired_at = token_dict[_expires_at]
+
+        return access_token, expired_at
+
+    def _get_refresh_token(self) -> str | None:
+        (storage_keyring, _) = get_token_store()
+
+        refresh_token = storage_keyring.get_password("HardPy", "refresh_token")
+        self._log.debug("Got refresh token from the storage keyring")
+        return refresh_token
+
+    def _get_api(self, endpoint: str) -> ApiClient:
+        token = self._get_token()
+        client_id = "hardpy-report-uploader"
+
+        extra = {
+            "client_id": client_id,
+            "audience": self._url.api,
+            "redirect_uri": "http://localhost/oauth2/callback",
+        }
+
+        session = OAuth2Session(
+            client_id,
+            token=token.as_dict(),
+            token_updater=self._token_update,
+        )
+
+        is_need_refresh = False
+        early_refresh = timedelta(seconds=30)
+
+        if token.expires_in and token.expires_in < early_refresh.seconds:
+            is_need_refresh = True
+
+        if token.access_token is None:
+            self._log.debug("Want to refresh token since don't have access token")
+            is_need_refresh = True
+
+        if is_need_refresh:
+            try:
+                ret = session.refresh_token(
+                    token_url=self._url.token,
+                    refresh_token=self._get_refresh_token(),
+                    verify=False,
+                    **extra,
+                )
+            except InvalidGrantError as exc:
+                raise StandCloudError(exc.description)
+            except RequestConnectionError as exc:
+                raise StandCloudError(exc.strerror)  # type: ignore
+            except MissingTokenError as exc:
+                raise StandCloudError(exc.description)
+            except InvalidURL:
+                msg = "Authentication URL is not available"
+                raise StandCloudError(msg)
+            self._token_update(ret)  # type: ignore
+
+        return ApiClient(self._url.api + "/" + endpoint, session=session, timeout=10)
+
+    def _get_token(self) -> BearerToken:
+        access_token, expires_at = self._get_access_token_info()
+        expires_in = self._get_expires_in(expires_at)
+
+        return BearerToken(
+            scope=["authelia.bearer.authz", "offline_access"],
+            token_type="bearer",  # noqa: S106
+            access_token=access_token,
+            expires_at=expires_at,
+            expires_in=expires_in,
+        )
+
+    def _get_service_name(self, addr: str) -> str:
+        addr_parts = addr.split(".")
+        number_of_parts = 3
+        service_position_in_address = 1
+        if isinstance(addr_parts, list) and len(addr_parts) >= number_of_parts:
+            return "/" + addr_parts[service_position_in_address]
+        msg = f"Invalid StandCloud address: {addr}"
+        raise StandCloudError(msg)

hardpy/common/stand_cloud/exception.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+
+class StandCloudError(Exception):
+    """Base StandCloud error."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(f"StandCloud error: {msg}")

hardpy/common/stand_cloud/oauth_callback.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import json
+from http import HTTPStatus
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+app = FastAPI()
+
+templates = Jinja2Templates(directory="templates")
+
+
+@app.route("/oauth2/callback")
+async def index(request: Request) -> None:
+    """OAuth2 callback page."""
+    print(json.dumps(dict(request.query_params)))  # noqa: T201
+    success_template = """
+    <html><body>
+        <h1>😎 Success</h1>
+        <p>You have been redirected from the Authentication Portal<p>
+        <p>Your received response data:</p>
+        <ul>
+        <li><b>Authorization Code</b>: <i>{{code}}</i></li>
+        <li><b>Issuer</b>: <i>{{iss}}</i></li>
+        <li><b>Scope of the access request</b>: <i>{{scope}}</i></li>
+        <li><b>State data</b>: <i>{{state}}</i></li>
+        </ul>
+        <p>It is the technical data needed by the application that requests access token.</p>
+        <p>Probably, the application already received this information.</p>
+        <p><b>ℹ️ You can close the window</b></p>
+        </body></html>
+    """  # noqa: E501, RUF001
+
+    error_template = """
+    <html><body>
+        <h1>😞 Error: '{{error}}'</h1>
+        <p>You have been redirected from the Authentication Portal<p>
+        <p>Your received response data:</p>
+        <ul>
+        <li><b>Error description</b>: <i>{{error_description}}</i></li>
+        <li><b>Issuer</b>: <i>{{iss}}</i></li>
+        <li><b>State data</b>: <i>{{state}}</i></li>
+        </ul>
+        <p>It is the technical data needed by the application that requests access token.</p>
+        <p>Probably, the application already received this information.</p>
+        <p><b>ℹ️ You can close the window</b></p>
+        </body></html>
+    """  # noqa: E501, RUF001
+
+    if request.query_params.get("code") is not None:
+        return HTMLResponse(
+            content=success_template.replace(
+                "{{code}}",
+                request.query_params.get("code"),  # type: ignore
+            )
+            .replace("{{iss}}", request.query_params.get("iss"))
+            .replace("{{scope}}", request.query_params.get("scope"))
+            .replace("{{state}}", request.query_params.get("state")),
+            status_code=HTTPStatus.OK,
+        )
+
+    if request.query_params.get("error") is not None:
+        return HTMLResponse(
+            content=error_template.replace(
+                "{{error}}",
+                request.query_params.get("error"),  # type: ignore
+            )
+            .replace(
+                "{{error_description}}",
+                request.query_params.get("error_description"),
+            )
+            .replace("{{iss}}", request.query_params.get("iss"))
+            .replace("{{state}}", request.query_params.get("state")),
+            status_code=HTTPStatus.OK,
+        )
+
+    server_error = """
+    <html><body>
+        <h1>Internal Server Error'</h1>
+        </body></html>
+    """
+
+    return HTMLResponse(
+        content=server_error,
+        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+    ) # type: ignore
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=8088)