hardpy 0.10.1__py3-none-any.whl → 0.11.1__py3-none-any.whl

hardpy/pytest_hardpy/db/base_store.py

@@ -36,8 +36,8 @@ class BaseStore(BaseConnector):
         """
         return glom(self._doc, key)
 
-    def update_doc(self, key: str, value: Any) -> None:  # noqa: ANN401
-        """Update document.
+    def update_doc_value(self, key: str, value: Any) -> None:  # noqa: ANN401
+        """Update document value.
 
         HardPy collecting uses a simple key without dots.
         Assign is used to update a document.
@@ -60,6 +60,11 @@ class BaseStore(BaseConnector):
             self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
             self._doc = self._db.save(self._doc)
 
+    def update_doc(self) -> None:
+        """Update current document by database."""
+        self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
+        self._doc = self._db.get(self._doc_id)
+
     def get_document(self) -> ModelMetaclass:
         """Get document by schema.
 

hardpy/pytest_hardpy/db/const.py

@@ -32,6 +32,9 @@ class DatabaseField(str, Enum):
     TITLE = "title"
     VISIBLE = "visible"
     IMAGE = "image"
+    HTML = "html"
     ID = "id"
     FONT_SIZE = "font_size"
     ALERT = "alert"
+    OPERATOR_DATA = "operator_data"
+    DIALOG = "dialog"

hardpy/pytest_hardpy/db/schema/v1.py

@@ -204,6 +204,24 @@ class TestStand(BaseModel):
     location: str | None = None
 
 
+class OperatorData(BaseModel):
+    """Operator data from operator panel.
+
+    Example:
+    ```
+    {
+      "operator_data": {
+        "dialog": "hello",
+      }
+    }
+    ```
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    dialog: str | None = None
+
+
 class ResultStateStore(IBaseResult):
     """Test run description.
 
@@ -218,6 +236,9 @@ class ResultStateStore(IBaseResult):
       "status": "failed",
       "name": "hardpy-stand",
       "alert": "",
+      "operator_data": {
+        "dialog": ""
+      },
       "dut": {
         "serial_number": "92c5a4bb-ecb0-42c5-89ac-e0caca0919fd",
         "part_number": "part_1",
@@ -305,6 +326,7 @@ class ResultStateStore(IBaseResult):
     modules: dict[str, ModuleStateStore] = {}
     operator_msg: dict = {}
     alert: str
+    operator_data: OperatorData
 
 
 class ResultRunStore(IBaseResult):

hardpy/pytest_hardpy/plugin.py

@@ -56,17 +56,22 @@ def pytest_addoption(parser: Parser) -> None:
         default=con_data.database_url,
         help="database url",
     )
+    parser.addoption(
+        "--hardpy-tests-name",
+        action="store",
+        help="HardPy tests suite name",
+    )
+    # TODO (xorialexandrov): Remove --hardpy-sp and --hardpy-sh in HardPy major version.
+    # Addoptions left for compatibility with version 0.10.1 and below
     parser.addoption(
         "--hardpy-sp",
         action="store",
-        default=con_data.socket_port,
-        help="internal socket port",
+        help="DEPRECATED, UNUSED: internal socket port",
     )
     parser.addoption(
         "--hardpy-sh",
         action="store",
-        default=con_data.socket_host,
-        help="internal socket host",
+        help="DEPRECATED, UNUSED: internal socket host",
     )
     parser.addoption(
         "--hardpy-clear-database",
@@ -117,6 +122,7 @@ class HardpyPlugin:
         self._results = {}
         self._post_run_functions: list[Callable] = []
         self._dependencies = {}
+        self._tests_name: str = ""
 
         if system() == "Linux":
             signal.signal(signal.SIGTERM, self._stop_handler)
@@ -134,15 +140,13 @@ class HardpyPlugin:
         if database_url:
             con_data.database_url = str(database_url)  # type: ignore
 
-        is_clear_database = config.getoption("--hardpy-clear-database")
-
-        socket_port = config.getoption("--hardpy-sp")
-        if socket_port:
-            con_data.socket_port = int(socket_port)  # type: ignore
+        tests_name = config.getoption("--hardpy-tests-name")
+        if tests_name:
+            self._tests_name = str(tests_name)
+        else:
+            self._tests_name = str(PurePath(config.rootpath).name)
 
-        socket_host = config.getoption("--hardpy-sh")
-        if socket_host:
-            con_data.socket_host = str(socket_host)  # type: ignore
+        is_clear_database = config.getoption("--hardpy-clear-database")
 
         sc_address = config.getoption("--sc-address")
         if sc_address:
@@ -182,11 +186,11 @@ class HardpyPlugin:
     def pytest_collection_modifyitems(
         self,
         session: Session,
-        config: Config,
+        config: Config,  # noqa: ARG002
         items: list[Item],  # noqa: ARG002
     ) -> None:
         """Call after collection phase."""
-        self._reporter.init_doc(str(PurePath(config.rootpath).name))
+        self._reporter.init_doc(self._tests_name)
 
         nodes = {}
         modules = set()
@@ -264,8 +268,8 @@ class HardpyPlugin:
 
         status = TestStatus.RUN
         is_skip_test = self._is_skip_test(node_info)
+        self._reporter.set_module_start_time(node_info.module_id)
         if not is_skip_test:
-            self._reporter.set_module_start_time(node_info.module_id)
             self._reporter.set_case_start_time(node_info.module_id, node_info.case_id)
         else:
             status = TestStatus.SKIPPED
@@ -324,7 +328,11 @@ class HardpyPlugin:
 
     def pytest_runtest_logreport(self, report: TestReport) -> bool | None:
         """Call after call of each test item."""
-        if report.when != "call" and report.failed is False:
+        is_skipped_by_plugin: bool = False
+        if report.when == "setup" and report.skipped is True:
+            # plugin-skipped tests should not have start and stop times
+            is_skipped_by_plugin = True
+        elif report.when != "call" and report.failed is False:
             # ignore setup and teardown phase or continue processing setup
             # and teardown failure (fixture exception handler)
             return True
@@ -337,10 +345,9 @@ class HardpyPlugin:
             case_id,
             TestStatus(report.outcome),
         )
-        self._reporter.set_case_stop_time(
-            module_id,
-            case_id,
-        )
+        # update case stop_time in non-skipped tests or user-skipped tests
+        if report.skipped is False or is_skipped_by_plugin is False:
+            self._reporter.set_case_stop_time(module_id, case_id)
 
         assertion_msg = self._decode_assertion_msg(report.longrepr)
         self._reporter.set_assertion_msg(module_id, case_id, assertion_msg)

hardpy/pytest_hardpy/pytest_call.py

@@ -2,10 +2,9 @@
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 from __future__ import annotations
 
-import socket
 from dataclasses import dataclass
 from os import environ
-from select import select
+from time import sleep
 from typing import Any
 from uuid import uuid4
 
@@ -19,12 +18,12 @@ from hardpy.pytest_hardpy.db import (
 )
 from hardpy.pytest_hardpy.reporter import RunnerReporter
 from hardpy.pytest_hardpy.utils import (
-    ConnectionData,
     DialogBox,
     DuplicatePartNumberError,
     DuplicateSerialNumberError,
     DuplicateTestStandLocationError,
     DuplicateTestStandNameError,
+    HTMLComponent,
     ImageComponent,
 )
 
@@ -279,6 +278,7 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:  # noqa: ANN401
           If the title_bar field is missing, it is the case name.
         - widget (DialogBoxWidget | None): Widget information.
         - image (ImageComponent | None): Image information.
+        - html (HTMLComponent | None): HTML information.
 
     Returns:
         Any: An object containing the user's response.
@@ -312,18 +312,18 @@ def run_dialog_box(dialog_box_data: DialogBox) -> Any:  # noqa: ANN401
     reporter.set_doc_value(key, dialog_box_data.to_dict(), statestore_only=True)
     reporter.update_db_by_doc()
 
-    # get socket data
-    input_dbx_data = _get_socket_raw_data()
+    input_dbx_data = _get_operator_data()
 
     _cleanup_widget(reporter, key)
     return dialog_box_data.widget.convert_data(input_dbx_data)
 
 
-def set_operator_message(
+def set_operator_message(  # noqa: PLR0913
     msg: str,
     title: str | None = None,
     block: bool = True,
     image: ImageComponent | None = None,
+    html: HTMLComponent | None = None,
     font_size: int = 14,
 ) -> None:
     """Set operator message.
@@ -334,7 +334,8 @@ def set_operator_message(
     Args:
         msg (str): message
         title (str | None): title
-        image (ImageComponent | None): operator message info
+        image (ImageComponent | None): operator message image
+        html (HTMLComponent | None): operator message html page
         block (bool): if True, the function will block until the message is closed
         font_size (int): font size
     """
@@ -351,6 +352,7 @@ def set_operator_message(
         DF.TITLE: title,
         DF.VISIBLE: True,
         DF.IMAGE: image.to_dict() if image else None,
+        DF.HTML: html.to_dict() if html else None,
         DF.ID: str(uuid4()),
         DF.FONT_SIZE: int(font_size),
     }
@@ -358,10 +360,9 @@ def set_operator_message(
     reporter.update_db_by_doc()
 
     if block:
-        # get socket data
-        is_msg_visible = _get_socket_raw_data()
-
+        is_msg_visible = _get_operator_data()
         msg_data[DF.VISIBLE] = is_msg_visible
+
         reporter.set_doc_value(key, msg_data, statestore_only=True)
         reporter.update_db_by_doc()
 
@@ -414,37 +415,25 @@ def _get_current_test() -> CurrentTestInfo:
     return CurrentTestInfo(module_id=module_id, case_id=case_id)
 
 
-def _get_socket_raw_data() -> str:
-    # create socket connection
-    with socket.socket() as server:
-        server.setblocking(False)
-        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-
-        con_data = ConnectionData()
-        try:
-            server.bind((con_data.socket_host, con_data.socket_port))
-        except OSError as exc:
-            msg = "Socket creating error"
-            server.close()
-            raise RuntimeError(msg) from exc
-        server.listen(1)
-
-        client = None
-        while True:
-            ready_to_read, _, _ = select([server], [], [], 0.5)
-            if ready_to_read:
-                client, _ = server.accept()
-                break
-
-        # receive data
-        max_input_data_len = 1024
-        socket_data = client.recv(max_input_data_len).decode("utf-8")
-
-        # close connection
-        client.close()
-        server.close()
-
-        return socket_data
+def _get_operator_data() -> str:
+    """Get operator panel data.
+
+    Returns:
+        str: operator panel data
+    """
+    reporter = RunnerReporter()
+
+    data = ""
+    key = reporter.generate_key(DF.OPERATOR_DATA, DF.DIALOG)
+    while not data:
+        reporter.update_doc_by_db()
+
+        data = reporter.get_field(key)
+        if data:
+            reporter.set_doc_value(key, "", statestore_only=True)
+            break
+        sleep(0.1)
+    return data
 
 
 def _cleanup_widget(reporter: RunnerReporter, key: str) -> None:

hardpy/pytest_hardpy/pytest_wrapper.py

@@ -6,9 +6,10 @@ import signal
 import subprocess
 import sys
 from platform import system
-from socket import socket
 
 from hardpy.common.config import ConfigManager
+from hardpy.pytest_hardpy.db import DatabaseField as DF  # noqa: N817
+from hardpy.pytest_hardpy.reporter import RunnerReporter
 
 
 class PyTestWrapper:
@@ -16,6 +17,7 @@ class PyTestWrapper:
 
     def __init__(self) -> None:
         self._proc = None
+        self._reporter = RunnerReporter()
         self.python_executable = sys.executable
 
         # Make sure test structure is stored in DB
@@ -43,10 +45,8 @@ class PyTestWrapper:
                     "pytest",
                     "--hardpy-db-url",
                     self.config.database.connection_url(),
-                    "--hardpy-sp",
-                    str(self.config.socket.port),
-                    "--hardpy-sh",
-                    self.config.socket.host,
+                    "--hardpy-tests-name",
+                    self.config.tests_name,
                     "--sc-address",
                     self.config.stand_cloud.address,
                     "--sc-connection-only"
@@ -64,10 +64,8 @@ class PyTestWrapper:
                     "pytest",
                     "--hardpy-db-url",
                     self.config.database.connection_url(),
-                    "--hardpy-sp",
-                    str(self.config.socket.port),
-                    "--hardpy-sh",
-                    self.config.socket.host,
+                    "--hardpy-tests-name",
+                    self.config.tests_name,
                     "--sc-address",
                     self.config.stand_cloud.address,
                     "--sc-connection-only"
@@ -117,10 +115,8 @@ class PyTestWrapper:
             "--collect-only",
             "--hardpy-db-url",
             self.config.database.connection_url(),
-            "--hardpy-sp",
-            str(self.config.socket.port),
-            "--hardpy-sh",
-            self.config.socket.host,
+            "--hardpy-tests-name",
+            self.config.tests_name,
             "--hardpy-pt",
         ]
 
@@ -144,10 +140,10 @@ class PyTestWrapper:
             bool: True if dialog box was confirmed/closed, else False
         """
         try:
-            with socket() as client:
-                client.connect((self.config.socket.host, self.config.socket.port))
-                client.sendall(data.encode("utf-8"))
-                client.close()
+            self._reporter.update_doc_by_db()
+            key = self._reporter.generate_key(DF.OPERATOR_DATA, DF.DIALOG)
+            self._reporter.set_doc_value(key, data, statestore_only=True)
+            self._reporter.update_db_by_doc()
         except Exception:  # noqa: BLE001
             return False
         return True
@@ -159,3 +155,11 @@ class PyTestWrapper:
             bool | None: True if self._proc is not None
         """
         return self._proc and self._proc.poll() is None
+
+    def get_config(self) -> dict:
+        """Get HardPy configuration.
+
+        Returns:
+            dict: HardPy configuration
+        """
+        return ConfigManager().get_config().model_dump()

hardpy/pytest_hardpy/reporter/base.py

@@ -45,19 +45,24 @@ class BaseReporter:
             msg = "Both runstore_only and statestore_only cannot be True"
             raise ValueError(msg)
         if runstore_only:
-            self._runstore.update_doc(key, value)
+            self._runstore.update_doc_value(key, value)
             return
         if statestore_only:
-            self._statestore.update_doc(key, value)
+            self._statestore.update_doc_value(key, value)
             return
-        self._runstore.update_doc(key, value)
-        self._statestore.update_doc(key, value)
+        self._runstore.update_doc_value(key, value)
+        self._statestore.update_doc_value(key, value)
 
     def update_db_by_doc(self) -> None:
         """Update database by current document."""
         self._statestore.update_db()
         self._runstore.update_db()
 
+    def update_doc_by_db(self) -> None:
+        """Update document by current database."""
+        self._statestore.update_doc()
+        self._runstore.update_doc()
+
     def generate_key(self, *args: Any) -> str:  # noqa: ANN401
         """Generate key for database.
 

hardpy/pytest_hardpy/reporter/hook_reporter.py

@@ -38,6 +38,7 @@ class HookReporter(BaseReporter):
         self.set_doc_value(DF.ARTIFACT, {}, runstore_only=True)
         self.set_doc_value(DF.OPERATOR_MSG, {}, statestore_only=True)
         self.set_doc_value(DF.ALERT, "", statestore_only=True)
+        self.set_doc_value(DF.OPERATOR_DATA, {}, statestore_only=True)
 
         test_stand_tz = self.generate_key(DF.TEST_STAND, DF.TIMEZONE)
         self.set_doc_value(test_stand_tz, str(get_localzone().key))
@@ -45,6 +46,9 @@ class HookReporter(BaseReporter):
         test_stand_id_key = self.generate_key(DF.TEST_STAND, DF.HW_ID)
         self.set_doc_value(test_stand_id_key, machine_id())
 
+        operator_data_key = self.generate_key(DF.OPERATOR_DATA, DF.DIALOG)
+        self.set_doc_value(operator_data_key, "", statestore_only=True)
+
     def start(self) -> None:
         """Start test."""
         self._log.debug("Starting test run.")
@@ -54,6 +58,9 @@ class HookReporter(BaseReporter):
         self.set_doc_value(DF.PROGRESS, 0, statestore_only=True)
         self.set_doc_value(DF.ALERT, "", statestore_only=True)
 
+        operator_data_key = self.generate_key(DF.OPERATOR_DATA, DF.DIALOG)
+        self.set_doc_value(operator_data_key, "", statestore_only=True)
+
     def finish(self, status: TestStatus) -> None:
         """Finish test.
 

hardpy/pytest_hardpy/result/__init__.py

@@ -6,9 +6,13 @@ from hardpy.pytest_hardpy.result.report_loader.stand_cloud_loader import (
     StandCloudLoader,
 )
 from hardpy.pytest_hardpy.result.report_reader.couchdb_reader import CouchdbReader
+from hardpy.pytest_hardpy.result.report_reader.stand_cloud_reader import (
+    StandCloudReader,
+)
 
 __all__ = [
     "CouchdbLoader",
     "CouchdbReader",
     "StandCloudLoader",
+    "StandCloudReader",
 ]

hardpy/pytest_hardpy/result/couchdb_config.py

@@ -58,17 +58,17 @@ class CouchdbConfig:
 
         try:
             response = requests.get(host_url, timeout=5)
-        except requests.exceptions.RequestException:
+        except requests.exceptions.RequestException as exc:
             msg = f"Error CouchDB connecting to {host_url}."
-            raise RuntimeError(msg)  # noqa: B904
+            raise RuntimeError(msg) from exc
 
         # fmt: off
         try:
             couchdb_dict = ast.literal_eval(response._content.decode("utf-8"))  # type: ignore # noqa: SLF001
             couchdb_dict.get("couchdb", False)
-        except Exception:  # noqa: BLE001
+        except Exception as exc:
             msg = f"Address {host_url} does not provide CouchDB attributes."
-            raise RuntimeError(msg)  # noqa: B904
+            raise RuntimeError(msg) from exc
         # fmt: on
 
         credentials = f"{self.user}:{self.password}"
@@ -93,8 +93,6 @@ class CouchdbConfig:
                 if requests.get(request, timeout=5).status_code == success:
                     return "http"
                 raise OSError  # noqa: TRY301
-            except OSError:
+            except OSError as exc:
                 msg = f"Error connecting to couchdb server {self.host}:{self.port}."
-                raise RuntimeError(  # noqa: B904
-                    msg,
-                )
+                raise RuntimeError(msg) from exc

hardpy/pytest_hardpy/result/report_loader/stand_cloud_loader.py

@@ -4,9 +4,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from oauthlib.oauth2.rfc6749.errors import InvalidGrantError, TokenExpiredError
+from oauthlib.oauth2.rfc6749.errors import OAuth2Error
 from requests.exceptions import HTTPError
-from requests_oauth2client.tokens import ExpiredAccessToken
 
 from hardpy.common.stand_cloud.connector import StandCloudConnector, StandCloudError
 from hardpy.pytest_hardpy.utils import ConnectionData
@@ -45,16 +44,14 @@ class StandCloudLoader:
         Raises:
             StandCloudError: if report not uploaded to StandCloud
         """
-        api = self._sc_connector.get_api("api/test_run")
+        api = self._sc_connector.get_api("test_report")
 
         try:
             resp = api.post(verify=self._verify_ssl, json=report.model_dump())
-        except ExpiredAccessToken as exc:
-            raise StandCloudError(str(exc))  # type: ignore
-        except TokenExpiredError as exc:
-            raise StandCloudError(exc.description)
-        except InvalidGrantError as exc:
-            raise StandCloudError(exc.description)
+        except RuntimeError as exc:
+            raise StandCloudError(str(exc)) from exc
+        except OAuth2Error as exc:
+            raise StandCloudError(exc.description) from exc
         except HTTPError as exc:
             return exc.response  # type: ignore
 

hardpy/pytest_hardpy/result/report_reader/stand_cloud_reader.py

@@ -0,0 +1,84 @@
+# 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 typing import TYPE_CHECKING
+from urllib.parse import urlencode
+
+from oauthlib.oauth2.rfc6749.errors import OAuth2Error
+from requests.exceptions import RequestException
+
+from hardpy.common.stand_cloud.connector import StandCloudConnector, StandCloudError
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from requests import Response
+    from requests_oauth2client import ApiClient
+
+
+class StandCloudReader:
+    """StandCloud data reader.
+
+    The link to the documentation can be obtained by address:
+    https://service_name/integration/api/v1/docs
+
+    For example:
+    https://demo.standcloud.io/integration/api/v1/docs
+    """
+
+    def __init__(self, sc_connector: StandCloudConnector) -> None:
+        """Create StandCloud reader.
+
+        Args:
+            sc_connector (StandCloudConnector): StandCloud connector
+        """
+        self._verify_ssl = not __debug__
+        self._sc_connector = sc_connector
+
+    def test_run(self, run_id: str) -> Response:
+        """Get run data from '/test_run' endpoint.
+
+        Args:
+            run_id (str): UUIDv4 test run identifier.
+                Example: "3fa85f64-5717-4562-b3fc-2c963f66afa6"
+
+        Returns:
+            Response: test run data.
+        """
+        return self._request(endpoint=f"test_run/{run_id}")
+
+    def tested_dut(self, params: dict[str, Any]) -> Response:
+        """Get tested DUT's data from '/tested_dut' endpoint.
+
+        Args:
+            params (dict[str, Any]): tested DUT filters:
+                Examples: {
+                    "test_stand_name": "Stand 1",
+                    "part_number": "part_number_1",
+                    "firmware_version": "1.2.3",
+                }
+
+        Returns:
+            Response: tested dut data.
+        """
+        return self._request(endpoint="tested_dut", params=params)
+
+    def _request(self, endpoint: str, params: dict[str, Any] | None = None) -> Response:
+        api = self._build_api(endpoint=endpoint, params=params)
+        try:
+            resp = api.get(verify=self._verify_ssl)
+        except RuntimeError as exc:
+            raise StandCloudError(str(exc)) from exc
+        except OAuth2Error as exc:
+            raise StandCloudError(exc.description) from exc
+        except RequestException as exc:
+            return exc.response  # type: ignore
+
+        return resp
+
+    def _build_api(self, endpoint: str, params: dict | None = None) -> ApiClient:
+        if params is None:
+            return self._sc_connector.get_api(f"{endpoint}")
+        encoded_params = urlencode(params)
+        return self._sc_connector.get_api(f"{endpoint}?{encoded_params}")

hardpy/pytest_hardpy/utils/__init__.py

@@ -7,6 +7,7 @@ from hardpy.pytest_hardpy.utils.dialog_box import (
     BaseWidget,
     CheckboxWidget,
     DialogBox,
+    HTMLComponent,
     ImageComponent,
     MultistepWidget,
     NumericInputWidget,
@@ -36,6 +37,7 @@ __all__ = [
     "DuplicateSerialNumberError",
     "DuplicateTestStandLocationError",
     "DuplicateTestStandNameError",
+    "HTMLComponent",
     "ImageComponent",
     "ImageError",
     "MultistepWidget",

hardpy/pytest_hardpy/utils/connection_data.py

@@ -1,8 +1,6 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
-from socket import gethostname
-
 from hardpy.pytest_hardpy.utils.singleton import SingletonMeta
 
 
@@ -11,7 +9,5 @@ class ConnectionData(metaclass=SingletonMeta):
 
     def __init__(self) -> None:
         self.database_url: str = "http://dev:dev@localhost:5984/"
-        self.socket_host: str = gethostname()
-        self.socket_port: int = 6525
         self.sc_address: str = ""
         self.sc_connection_only: bool = False