hardpy 0.1.0__py3-none-any.whl

hardpy/hardpy_panel/runner.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+
+from uvicorn import run as uvicorn_run
+
+from hardpy.pytest_hardpy.utils import ConfigData
+
+
+def run():
+    """Start server for frontend."""
+    config = ConfigData()
+    parser = ArgumentParser(description="Usage: hardpy-panel [OPTION]... [PATH]")
+    # fmt: off
+    parser.add_argument("-dbu", "--db_user", default=config.db_user, help="database user")
+    parser.add_argument("-dbpw", "--db_pswd", default=config.db_pswd, help="database user password")  # noqa: E501
+    parser.add_argument("-dbp", "--db_port", type=int, default=config.db_port, help="database port number")  # noqa: E501
+    parser.add_argument("-dbh", "--db_host", type=str, default=config.db_host, help="database hostname")  # noqa: E501
+    parser.add_argument("-wh", "--web_host", type=str, default=config.web_host, help="web operator panel hostname")  # noqa: E501
+    parser.add_argument("-wp", "--web_port", type=str, default=config.web_port, help="web operator panel port")  # noqa: E501
+    parser.add_argument("path", type=str, nargs='?', help="path to test directory")
+    # fmt: on
+
+    args = parser.parse_args()
+
+    config.db_user = args.db_user
+    config.db_pswd = args.db_pswd
+    config.db_port = args.db_port
+    config.db_host = args.db_host
+    config.web_host = args.web_host
+    config.web_port = args.web_port
+
+    path = Path(args.path) if args.path else Path.cwd()
+
+    config.tests_dir = path
+
+    if not config.tests_dir.exists():
+        print(f"Directory not found: {path}")
+        sys.exit()
+
+    uvicorn_run(
+        "hardpy.hardpy_panel.api:app",
+        host=config.web_host,
+        port=config.web_port,
+        log_level="critical",
+    )
+
+
+run()

hardpy/pytest_hardpy/db/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from hardpy.pytest_hardpy.db.schema import ResultRunStore, ResultStateStore
+from hardpy.pytest_hardpy.db.statestore import StateStore
+from hardpy.pytest_hardpy.db.runstore import RunStore
+from hardpy.pytest_hardpy.db.base_store import BaseStore
+from hardpy.pytest_hardpy.db.const import DatabaseField
+
+
+__all__ = [
+    "BaseStore",
+    "DatabaseField",
+    "ResultRunStore",
+    "ResultStateStore",
+    "StateStore",
+    "RunStore",
+]

hardpy/pytest_hardpy/db/base_connector.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from pycouchdb.client import Database
+from pycouchdb.exceptions import Conflict
+
+from hardpy.pytest_hardpy.db.base_server import BaseServer
+
+
+class BaseConnector(BaseServer):
+    """Base class for CouchDB connector."""
+
+    def __init__(self, db_name: str):
+        super().__init__()
+        self._db_name = db_name
+        self._db = self._init_db()
+        self._doc_id = "current"
+
+    def _init_db(self) -> Database:
+        try:
+            return self._db_srv.create(self._db_name)  # type: ignore
+        except Conflict:
+            # database is already created
+            return self._db_srv.database(self._db_name)

hardpy/pytest_hardpy/db/base_server.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from pycouchdb import Server as DbServer
+
+from hardpy.pytest_hardpy.utils import ConfigData
+
+
+class BaseServer(object):
+    """Base class for CouchDB server."""
+
+    def __init__(self):
+        config = ConfigData()
+        self._db_srv = DbServer(config.connection_string)

hardpy/pytest_hardpy/db/base_store.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from logging import getLogger
+from typing import Any
+
+from glom import assign, glom
+from pycouchdb.exceptions import Conflict, NotFound
+from pydantic._internal._model_construction import ModelMetaclass
+
+from hardpy.pytest_hardpy.db.base_connector import BaseConnector
+from hardpy.pytest_hardpy.db.const import DatabaseField as DF
+
+
+class BaseStore(BaseConnector):
+    """HardPy base storage interface for CouchDB."""
+
+    def __init__(self, db_name: str):
+        super().__init__(db_name)
+        self._log = getLogger(__name__)
+        self._doc: dict = self._init_doc()
+        self._schema: ModelMetaclass
+
+    def compact(self):
+        """Compact database."""
+        self._db.compact()
+
+    def get_field(self, key: str) -> Any:
+        """Get field from the state store.
+
+        Args:
+            key (str): field name
+
+        Returns:
+            Any: field value
+        """
+        return glom(self._doc, key)
+
+    def set_value(self, key: str, value):
+        """Set a value in the state store."""
+        assign(self._doc, key, value)
+        try:
+            self._doc = self._db.save(self._doc)
+        except Conflict as exc:
+            self._log.error(
+                f"Error while saving runner document: {exc} "
+                f"when trying to save key={key}, value={value}. "
+                "Current document will be changed by "
+                "document from database."
+            )
+            self._doc = self._db.get(self._doc_id)
+
+    def get_document(self) -> ModelMetaclass:
+        """Get document by schema.
+
+        Returns:
+            ModelMetaclass: document by schema
+        """
+        self._doc = self._db.get(self._doc_id)
+        return self._schema(**self._doc)
+
+    def _init_doc(self) -> dict:
+        try:
+            doc = self._db.get(self._doc_id)
+        except NotFound:
+            return {
+                "_id": self._doc_id,
+                DF.MODULES: {},
+                DF.DUT: {
+                    DF.SERIAL_NUMBER: None,
+                    DF.INFO: {},
+                },
+                DF.TEST_STAND: {},
+                DF.DRIVERS: {},
+            }
+
+        if DF.MODULES not in doc:
+            doc[DF.MODULES] = {}
+
+        for item in (DF.TEST_STAND, DF.DRIVERS):
+            doc[item] = {}
+
+        doc[DF.DUT] = {
+            DF.SERIAL_NUMBER: None,
+            DF.INFO: {},
+        }
+
+        return doc

hardpy/pytest_hardpy/db/const.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from enum import Enum
+
+
+class DatabaseField(str, Enum):  # noqa: WPS600
+    """Database field."""
+
+    NAME = "name"
+    STATUS = "status"
+    START_TIME = "start_time"
+    STOP_TIME = "stop_time"
+    ASSERTION_MSG = "assertion_msg"
+    MSG = "msg"
+    MODULES = "modules"
+    CASES = "cases"
+    TIMEZONE = "timezone"
+    PROGRESS = "progress"
+    ARTIFACT = "artifact"
+    DUT = "dut"
+    INFO = "info"
+    TEST_STAND = "test_stand"
+    SERIAL_NUMBER = "serial_number"
+    DRIVERS = "drivers"

hardpy/pytest_hardpy/db/runstore.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from logging import getLogger
+
+from pycouchdb.exceptions import Conflict, NotFound
+
+from hardpy.pytest_hardpy.db.base_store import BaseStore
+from hardpy.pytest_hardpy.db import ResultRunStore
+from hardpy.pytest_hardpy.utils import Singleton
+
+
+class RunStore(Singleton, BaseStore):
+    """HardPy run storage interface for CouchDB.
+
+    Save state and case artifact.
+    """
+
+    def __init__(self):
+        if not self._initialized:
+            super().__init__("runstore")
+            self._log = getLogger(__name__)
+            try:
+                # Clear the runstore database before each launch
+                self._db.delete(self._doc_id)
+            except (Conflict, NotFound):
+                self._log.debug("Runstore database will be created for the first time")
+            self._doc: dict = self._init_doc()
+            self._schema = ResultRunStore
+            self._initialized = True

hardpy/pytest_hardpy/db/schema.py

@@ -0,0 +1,292 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from typing import Optional
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from hardpy.pytest_hardpy.utils import TestStatus as Status
+
+
+class IBaseResult(BaseModel):
+    """Base class for all result models."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    status: Status
+    stop_time: int | None
+    start_time: int | None
+    name: str
+
+
+class CaseStateStore(IBaseResult):
+    """Test case description.
+
+    Example:
+    "test_one": {
+        "status": "passed",
+        "name": "Test 2",
+        "start_time": 1695817188,
+        "stop_time": 1695817189,
+        "assertion_msg": null,
+        "msg": null
+    }
+    """
+
+    assertion_msg: str | None = None
+    msg: dict | None = None
+
+
+class CaseRunStore(IBaseResult):
+    """Test case description with artifact.
+
+    Example:
+    "test_one": {
+        "status": "passed",
+        "name": "Test 2",
+        "start_time": 1695817188,
+        "stop_time": 1695817189,
+        "assertion_msg": null,
+        "msg": null,
+        "artifact": {}
+    }
+    """
+
+    assertion_msg: str | None = None
+    msg: dict | None = None
+    artifact: Optional[dict] = {}
+
+
+class ModuleStateStore(IBaseResult):
+    """Test module description.
+
+    Example:
+    "test_2_b": {
+      "status": "passed",
+      "name": "Module 2",
+      "start_time": 1695816886,
+      "stop_time": 1695817016,
+      "cases": {
+        "test_one": {
+          "status": "passed",
+          "name": "Test 1",
+          "start_time": 1695817015,
+          "stop_time": 1695817016,
+          "assertion_msg": null,
+          "msg": null
+        }
+      }
+    }
+    """
+
+    cases: dict[str, CaseStateStore] = {}
+
+
+class ModuleRunStore(IBaseResult):
+    """Test module description.
+
+    Example:
+    "test_2_b": {
+      "status": "passed",
+      "name": "Module 2",
+      "start_time": 1695816886,
+      "stop_time": 1695817016,
+      "artifact": {},
+      "cases": {
+        "test_one": {
+          "status": "passed",
+          "name": "Test 1",
+          "start_time": 1695817015,
+          "stop_time": 1695817016,
+          "assertion_msg": null,
+          "msg": null,
+          "artifact": {}
+        }
+      }
+    }
+    """
+
+    cases: dict[str, CaseRunStore] = {}
+    artifact: Optional[dict] = {}
+
+
+class Dut(BaseModel):
+    """Device under test description.
+
+    Example:
+    "dut": {
+        "serial_number": "a9ad8dca-2c64-4df8-a358-c21e832a32e4",
+        "info": {
+        "batch": "test_batch",
+        "board_rev": "rev_1"
+        }
+    },
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    serial_number: str | None
+    info: dict = {}
+
+
+class ResultStateStore(IBaseResult):
+    """Test run description.
+
+    Example:
+    {
+      "_rev": "44867-3888ae85c19c428cc46685845953b483",
+      "_id": "current",
+      "progress": 100,
+      "stop_time": 1695817266,
+      "timezone": [
+        "CET",
+        "CET"
+      ],
+      "start_time": 1695817263,
+      "status": "failed",
+      "name": "hardpy-stand",
+      "dut": {
+        "serial_number": "92c5a4bb-ecb0-42c5-89ac-e0caca0919fd",
+        "info": {
+          "batch": "test_batch",
+          "board_rev": "rev_1"
+        }
+      },
+      "test_stand": {
+        "name": "Test stand 1"
+      },
+      "drivers": {
+        "driver_1": "driver info",
+        "driver_2": {
+          "state": "active",
+          "port": 8000
+        }
+      },
+      "modules": {
+        "test_1_a": {
+          "status": "failed",
+          "name": "Module 1",
+          "start_time": 1695816884,
+          "stop_time": 1695817265,
+          "cases": {
+            "test_dut_info": {
+              "status": "passed",
+              "name": "DUT info ",
+              "start_time": 1695817263,
+              "stop_time": 1695817264,
+              "assertion_msg": null,
+              "msg": null
+            },
+            "test_minute_parity": {
+              "status": "failed",
+              "name": "Test 1",
+              "start_time": 1695817264,
+              "stop_time": 1695817264,
+              "assertion_msg": "The test failed because minute 21 is odd! Try again!",
+              "msg": [
+                "Current minute 21"
+              ]
+            },
+          }
+        },
+      }
+    }
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    rev: str = Field(..., alias="_rev")
+    id: str = Field(..., alias="_id")
+    progress: int
+    timezone: tuple[str, str] | None = None
+    test_stand: dict = {}
+    dut: Dut
+    modules: dict[str, ModuleStateStore] = {}
+    drivers: Optional[dict] = {}
+
+
+class ResultRunStore(IBaseResult):
+    """Test run description.
+
+    Example:
+    {
+      "_rev": "44867-3888ae85c19c428cc46685845953b483",
+      "_id": "current",
+      "progress": 100,
+      "stop_time": 1695817266,
+      "timezone": [
+        "CET",
+        "CET"
+      ],
+      "start_time": 1695817263,
+      "status": "failed",
+      "name": "hardpy-stand",
+      "dut": {
+        "serial_number": "92c5a4bb-ecb0-42c5-89ac-e0caca0919fd",
+        "info": {
+          "batch": "test_batch",
+          "board_rev": "rev_1"
+        }
+      },
+      "test_stand": {
+        "name": "Test stand 1"
+      },
+      "drivers": {
+        "driver_1": "driver info",
+        "driver_2": {
+          "state": "active",
+          "port": 8000
+        }
+      },
+      "artifact": {},
+      "modules": {
+        "test_1_a": {
+          "status": "failed",
+          "name": "Module 1",
+          "start_time": 1695816884,
+          "stop_time": 1695817265,
+          "artifact": {},
+          "cases": {
+            "test_dut_info": {
+              "status": "passed",
+              "name": "DUT info",
+              "start_time": 1695817263,
+              "stop_time": 1695817264,
+              "assertion_msg": null,
+              "msg": null,
+              "artifact": {}
+            },
+            "test_minute_parity": {
+              "status": "failed",
+              "name": "Test 1",
+              "start_time": 1695817264,
+              "stop_time": 1695817264,
+              "assertion_msg": "The test failed because minute 21 is odd! Try again!",
+              "msg": [
+                "Current minute 21"
+              ],
+              "artifact": {
+                "data_str": "123DATA",
+                "data_int": 12345,
+                "data_dict": {
+                  "test_key": "456DATA"
+                }
+              }
+            },
+          }
+        },
+      }
+    }
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    rev: str = Field(..., alias="_rev")
+    id: str = Field(..., alias="_id")
+    progress: int
+    timezone: tuple[str, str] | None = None
+    test_stand: dict = {}
+    dut: Dut
+    modules: dict[str, ModuleRunStore] = {}
+    drivers: Optional[dict] = {}
+    artifact: Optional[dict] = {}

hardpy/pytest_hardpy/db/statestore.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from logging import getLogger
+
+from hardpy.pytest_hardpy.db.base_store import BaseStore
+from hardpy.pytest_hardpy.db import ResultStateStore
+from hardpy.pytest_hardpy.utils import Singleton
+
+
+class StateStore(Singleton, BaseStore):
+    """HardPy state storage interface for CouchDB."""
+
+    def __init__(self):
+        if not self._initialized:
+            super().__init__("statestore")
+            self._log = getLogger(__name__)
+            self._schema = ResultStateStore
+            self._initialized = True