hardpy 0.15.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

hardpy/__init__.py

@@ -2,8 +2,16 @@
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from hardpy.common.stand_cloud import StandCloudConnector, StandCloudError
+from hardpy.pytest_hardpy.db import (
+    Chart,
+    Instrument,
+    NumericMeasurement,
+    StringMeasurement,
+    SubUnit,
+)
 from hardpy.pytest_hardpy.pytest_call import (
     ErrorCode,
+    PassFailDialog,
     clear_operator_message,
     get_current_attempt,
     get_current_report,
@@ -43,7 +51,6 @@ from hardpy.pytest_hardpy.result import (
 from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
 from hardpy.pytest_hardpy.utils import (
     BaseWidget,
-    Chart,
     ChartType,
     CheckboxWidget,
     ComparisonOperation,
@@ -52,14 +59,10 @@ from hardpy.pytest_hardpy.utils import (
     Group,
     HTMLComponent,
     ImageComponent,
-    Instrument,
     MultistepWidget,
     NumericInputWidget,
-    NumericMeasurement,
     RadiobuttonWidget,
     StepWidget,
-    StringMeasurement,
-    SubUnit,
     TestStandNumberError,
     TextInputWidget,
 )
@@ -82,6 +85,7 @@ __all__ = [
     "MultistepWidget",
     "NumericInputWidget",
     "NumericMeasurement",
+    "PassFailDialog",
     "RadiobuttonWidget",
     "StandCloudConnector",
     "StandCloudError",
@@ -101,7 +105,6 @@ __all__ = [
     "set_case_chart",
     "set_case_measurement",
     "set_driver_info",
-    "set_dut",
     "set_dut_info",
     "set_dut_name",
     "set_dut_part_number",

hardpy/cli/cli.py

@@ -28,7 +28,7 @@ if __debug__:
     disable_warnings(InsecureRequestWarning)
 
 cli = typer.Typer(add_completion=False)
-default_config = ConfigManager().get_config()
+default_config = HardpyConfig()
 
 
 @cli.command()
@@ -92,7 +92,8 @@ def init(  # noqa: PLR0913
         sc_connection_only (bool): Flag to check StandCloud service availability
     """
     dir_path = Path(Path.cwd() / tests_dir if tests_dir else "tests")
-    ConfigManager().init_config(
+    config_manager = ConfigManager()
+    config_manager.init_config(
         tests_name=tests_name if tests_name else dir_path.name,
         database_user=database_user,
         database_password=database_password,
@@ -112,7 +113,7 @@ def init(  # noqa: PLR0913
         Path.mkdir(dir_path / "database", exist_ok=True, parents=True)
 
     # create hardpy.toml
-    ConfigManager().create_config(dir_path)
+    config_manager.create_config(dir_path)
 
     config = _get_config(dir_path)
     template = TemplateGenerator(config)
@@ -151,12 +152,16 @@ def run(tests_dir: Annotated[Optional[str], typer.Argument()] = None) -> None:
 
     print(f"http://{config.frontend.host}:{config.frontend.port}\n")
 
-    uvicorn_run(
-        "hardpy.hardpy_panel.api:app",
-        host=config.frontend.host,
-        port=config.frontend.port,
-        log_level="critical",
-    )
+    try:
+        uvicorn_run(
+            "hardpy.hardpy_panel.api:app",
+            host=config.frontend.host,
+            port=config.frontend.port,
+            log_level="critical",
+        )
+    except RuntimeError as exc:
+        print(f"HardPy server cannot be started: {exc}")
+        sys.exit()
 
 
 @cli.command()
@@ -260,7 +265,8 @@ def sc_logout(address: Annotated[str, typer.Argument()]) -> None:
 
 def _get_config(tests_dir: str | None = None, validate: bool = False) -> HardpyConfig:
     dir_path = Path.cwd() / tests_dir if tests_dir else Path.cwd()
-    config = ConfigManager().read_config(dir_path)
+    config_manager = ConfigManager()
+    config = config_manager.read_config(dir_path)
 
     if not config:
         print(f"Config at path {dir_path} not found.")

hardpy/cli/template.py

@@ -5,9 +5,7 @@ from pathlib import Path
 
 from hardpy.common.config import HardpyConfig
 
-docker_compose_yaml = """version: "3.8"
-
-services:
+docker_compose_yaml = """services:
   couchserver:
     image: couchdb:3.4
     ports:
@@ -16,8 +14,11 @@ services:
       COUCHDB_USER: {}
       COUCHDB_PASSWORD: {}
     volumes:
-      - ./database/dbdata:/opt/couchdb/data
+      - couchdb_data:/opt/couchdb/data
       - ./database/couchdb.ini:/opt/couchdb/etc/local.ini
+
+volumes:
+  couchdb_data:
 """
 
 couchdb_ini = """; CouchDB Configuration Settings

hardpy/common/config.py

@@ -7,7 +7,9 @@ from pathlib import Path
 
 import tomli
 import tomli_w
-from pydantic import BaseModel, ConfigDict, ValidationError
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from hardpy.common.singleton import SingletonMeta
 
 logger = getLogger(__name__)
 
@@ -21,8 +23,14 @@ class DatabaseConfig(BaseModel):
     password: str = "dev"
     host: str = "localhost"
     port: int = 5984
+    doc_id: str = Field(exclude=True, default="")
+    url: str = Field(exclude=True, default="")
+
+    def model_post_init(self, __context) -> None:  # noqa: ANN001,PYI063
+        """Get database connection url."""
+        self.url = self.get_url()
 
-    def connection_url(self) -> str:
+    def get_url(self) -> str:
         """Get database connection url.
 
         Returns:
@@ -41,6 +49,19 @@ class FrontendConfig(BaseModel):
     host: str = "localhost"
     port: int = 8000
     language: str = "en"
+    full_size_button: bool = False
+    sound_on: bool = False
+    modal_result: ModalResultConfig = Field(default_factory=lambda: ModalResultConfig())
+
+
+class ModalResultConfig(BaseModel):
+    """Modal result configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    enable: bool = False
+    auto_dismiss_pass: bool = True
+    auto_dismiss_timeout: int = 5
 
 
 class StandCloudConfig(BaseModel):
@@ -63,16 +84,42 @@ class HardpyConfig(BaseModel, extra="allow"):
     frontend: FrontendConfig = FrontendConfig()
     stand_cloud: StandCloudConfig = StandCloudConfig()
 
+    def model_post_init(self, __context) -> None:  # noqa: ANN001,PYI063
+        """Get database document name."""
+        self.database.doc_id = self.get_doc_id()
+
+    def get_doc_id(self) -> str:
+        """Update database document name."""
+        return f"{self.frontend.host}_{self.frontend.port}"
+
 
-class ConfigManager:
+class ConfigManager(metaclass=SingletonMeta):
     """HardPy configuration manager."""
 
-    obj = HardpyConfig()
-    tests_path = Path.cwd()
+    def __init__(self) -> None:
+        self._config = HardpyConfig()
+        self._test_path = Path.cwd()
+
+    @property
+    def config(self) -> HardpyConfig:
+        """Get HardPy configuration.
+
+        Returns:
+            HardpyConfig: HardPy configuration
+        """
+        return self._config
+
+    @property
+    def tests_path(self) -> Path:
+        """Get tests path.
+
+        Returns:
+            Path: HardPy tests path
+        """
+        return self._tests_path
 
-    @classmethod
     def init_config(  # noqa: PLR0913
-        cls,
+        self,
         tests_name: str,
         database_user: str,
         database_password: str,
@@ -84,7 +131,9 @@ class ConfigManager:
         sc_address: str = "",
         sc_connection_only: bool = False,
     ) -> None:
-        """Initialize HardPy configuration.
+        """Initialize the HardPy configuration.
+
+        Only call once to create a configuration.
 
         Args:
             tests_name (str): Tests suite name.
@@ -98,34 +147,37 @@ class ConfigManager:
             sc_address (str): StandCloud address.
             sc_connection_only (bool): StandCloud check availability.
         """
-        cls.obj.tests_name = tests_name
-        cls.obj.database.user = database_user
-        cls.obj.database.password = database_password
-        cls.obj.database.host = database_host
-        cls.obj.database.port = database_port
-        cls.obj.frontend.host = frontend_host
-        cls.obj.frontend.port = frontend_port
-        cls.obj.frontend.language = frontend_language
-        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:
+        self._config.tests_name = tests_name
+        self._config.frontend.host = frontend_host
+        self._config.frontend.port = frontend_port
+        self._config.frontend.language = frontend_language
+        self._config.database.user = database_user
+        self._config.database.password = database_password
+        self._config.database.host = database_host
+        self._config.database.port = database_port
+        self._config.database.doc_id = self._config.get_doc_id()
+        self._config.database.url = self._config.database.get_url()
+        self._config.stand_cloud.address = sc_address
+        self._config.stand_cloud.connection_only = sc_connection_only
+
+    def create_config(self, parent_dir: Path) -> None:
         """Create HardPy configuration.
 
         Args:
             parent_dir (Path): Configuration file parent directory.
         """
-        if not cls.obj.stand_cloud.address:
-            del cls.obj.stand_cloud
-        if not cls.obj.tests_name:
-            del cls.obj.tests_name
-        config_str = tomli_w.dumps(cls.obj.model_dump())
+        config = self._config
+        if not self._config.stand_cloud.address:
+            del config.stand_cloud
+        if not self._config.tests_name:
+            del config.tests_name
+        if not self._config.database.doc_id:
+            del config.database.doc_id
+        config_str = tomli_w.dumps(config.model_dump())
         with Path.open(parent_dir / "hardpy.toml", "w") as file:
             file.write(config_str)
 
-    @classmethod
-    def read_config(cls, toml_path: Path) -> HardpyConfig | None:
+    def read_config(self, toml_path: Path) -> HardpyConfig | None:
         """Read HardPy configuration.
 
         Args:
@@ -134,10 +186,9 @@ class ConfigManager:
         Returns:
             HardpyConfig | None: HardPy configuration
         """
-        cls.tests_path = toml_path
+        self._tests_path = toml_path
         toml_file = toml_path / "hardpy.toml"
         if not toml_file.exists():
-            logger.error("File hardpy.toml not found at path: %s", toml_file)
             return None
         try:
             with Path.open(toml_path / "hardpy.toml", "rb") as f:
@@ -148,26 +199,8 @@ class ConfigManager:
             return None
 
         try:
-            cls.obj = HardpyConfig(**toml_data)
+            self._config = HardpyConfig(**toml_data)
         except ValidationError:
             logger.exception("Error parsing TOML")
             return None
-        return cls.obj
-
-    @classmethod
-    def get_config(cls) -> HardpyConfig:
-        """Get HardPy configuration.
-
-        Returns:
-            HardpyConfig: HardPy configuration
-        """
-        return cls.obj
-
-    @classmethod
-    def get_tests_path(cls) -> Path:
-        """Get tests path.
-
-        Returns:
-            Path: HardPy tests path
-        """
-        return cls.tests_path
+        return self._config

hardpy/{pytest_hardpy/utils → common}/singleton.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Everypin
+# 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
 

hardpy/hardpy_panel/api.py

@@ -2,6 +2,7 @@
 # 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 os
 import re
 from enum import Enum
@@ -107,34 +108,64 @@ def couch_connection() -> dict:
     Returns:
         dict[str, str]: couchdb connection string
     """
-    connection_url = ConfigManager().get_config().database.connection_url()
+    config_manager = ConfigManager()
 
     return {
-        "connection_str": connection_url,
+        "connection_str": config_manager.config.database.url,
     }
 
 
-@app.post("/api/confirm_dialog_box/{dialog_box_output}")
-def confirm_dialog_box(dialog_box_output: str) -> dict:
-    """Confirm dialog box.
+@app.get("/api/database_document_id")
+def database_document_id() -> dict:
+    """Get couchdb syncronized document name.
+
+    Returns:
+        dict[str, str]: couchdb connection string
+    """
+    config_manager = ConfigManager()
+    return {"document_id": config_manager.config.database.doc_id}
+
+
+@app.post("/api/confirm_dialog_box")
+def confirm_dialog_box(dbx_data: dict) -> dict:
+    """Confirm dialog box with unified JSON structure.
 
     Args:
-        dialog_box_output (str): output data from dialog box.
+        dbx_data: dict with 'result' (pass/fail/confirm) and 'data' (widget data)
 
     Returns:
         dict[str, RunStatus]: run status
     """
-    hex_base = 16
-    unquoted_string = unquote(dialog_box_output)
+    RESULT_KEY = "result"  # noqa: N806
+    DATA_KEY = "data"  # noqa: N806
+    STATUS_KEY = "status"  # noqa: N806
+    EMPTY_STRING = ""  # noqa: N806
+
+    HEX_BASE = 16  # noqa: N806
+    HEX_PATTERN = r"%([0-9a-fA-F]{2})"  # noqa: N806
+
+    result = dbx_data.get(RESULT_KEY, EMPTY_STRING)
+    widget_data = dbx_data.get(DATA_KEY, EMPTY_STRING)
+
+    unquoted_string = unquote(widget_data)
     decoded_string = re.sub(
-        "%([0-9a-fA-F]{2})",
-        lambda match: chr(int(match.group(1), hex_base)),
+        HEX_PATTERN,
+        lambda match: chr(int(match.group(1), HEX_BASE)),
         unquoted_string,
     )
 
-    if app.state.pytest_wrp.send_data(str(decoded_string)):
-        return {"status": Status.BUSY}
-    return {"status": Status.ERROR}
+    # Create JSON structure for all dialog types
+    dialog_result = {
+        RESULT_KEY: result,
+        DATA_KEY: decoded_string,
+    }
+
+    # Convert to JSON string for transmission
+    combined_data = json.dumps(dialog_result)
+
+    if app.state.pytest_wrp.send_data(combined_data):
+        return {STATUS_KEY: Status.BUSY}
+    return {STATUS_KEY: Status.ERROR}
 
 
 @app.post("/api/confirm_operator_msg/{is_msg_visible}")

hardpy/hardpy_panel/frontend/dist/assets/{allPaths-CV5wjLMB.js → allPaths-COgYwK8M.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-6RIgWzcZ.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-DLOviMB1.js";import{I as e}from"./index-B-fsa5Ru.js";import{p as r,I as s}from"./index-B3wEgxl0.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/hardpy_panel/frontend/dist/assets/{allPathsLoader-JIzW_pSb.js → allPathsLoader-B8vBKA-e.js}

@@ -1,2 +1,2 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-CV5wjLMB.js","assets/index-xb4M2ucX.js","assets/index-BMEat_ws.js","assets/index-6RIgWzcZ.js","assets/index-BwCQzehg.css"])))=>i.map(i=>d[i]);
-import{_ as o,a as n,b as i}from"./index-6RIgWzcZ.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-CV5wjLMB.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-COgYwK8M.js","assets/index-DLOviMB1.js","assets/index-B-fsa5Ru.js","assets/index-B3wEgxl0.js","assets/index-B7T9xvaW.css"])))=>i.map(i=>d[i]);
+import{_ as o,a as n,b as i}from"./index-B3wEgxl0.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-COgYwK8M.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};