hardpy 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

hardpy/__init__.py

@@ -4,6 +4,8 @@
 from hardpy.pytest_hardpy.result import CouchdbLoader
 from hardpy.pytest_hardpy.utils import (
     DuplicateSerialNumberError,
+    DuplicatePartNumberError,
+    DuplicateTestStandNameError,
     DuplicateDialogBoxError,
 )
 from hardpy.pytest_hardpy.result.couchdb_config import CouchdbConfig
@@ -21,6 +23,8 @@ from hardpy.pytest_hardpy.pytest_call import (
     get_current_report,
     set_dut_info,
     set_dut_serial_number,
+    set_dut_part_number,
+    set_stand_name,
     set_stand_info,
     set_case_artifact,
     set_module_artifact,
@@ -28,6 +32,7 @@ from hardpy.pytest_hardpy.pytest_call import (
     set_message,
     set_driver_info,
     run_dialog_box,
+    set_operator_message,
 )
 
 __all__ = [
@@ -37,16 +42,21 @@ __all__ = [
     "get_current_report",
     # Errors
     "DuplicateSerialNumberError",
+    "DuplicatePartNumberError",
+    "DuplicateTestStandNameError",
     "DuplicateDialogBoxError",
     # Database info
     "set_dut_info",
     "set_dut_serial_number",
+    "set_dut_part_number",
+    "set_stand_name",
     "set_stand_info",
     "set_case_artifact",
     "set_module_artifact",
     "set_run_artifact",
     "set_message",
     "set_driver_info",
+    "set_operator_message",
     # Dialog boxes
     "run_dialog_box",
     "DialogBox",

hardpy/cli/cli.py

@@ -0,0 +1,145 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+from typing_extensions import Annotated
+
+import typer
+from uvicorn import run as uvicorn_run
+
+from hardpy.cli.template import TemplateGenerator
+from hardpy.common.config import ConfigManager
+
+cli = typer.Typer(add_completion=False)
+default_config = ConfigManager().get_config()
+
+
+@cli.command()
+def init(  # noqa: WPS211
+    tests_dir: Annotated[Optional[str], typer.Argument()] = None,
+    create_database: bool = typer.Option(
+        True,
+        help="Create CouchDB database.",
+    ),
+    database_user: str = typer.Option(
+        default_config.database.user,
+        help="Specify a database user.",
+    ),
+    database_password: str = typer.Option(
+        default_config.database.password,
+        help="Specify a database user password.",
+    ),
+    database_host: str = typer.Option(
+        default_config.database.host,
+        help="Specify a database host.",
+    ),
+    database_port: int = typer.Option(
+        default_config.database.port,
+        help="Specify a database port.",
+    ),
+    frontend_host: str = typer.Option(
+        default_config.frontend.host,
+        help="Specify a frontend host.",
+    ),
+    frontend_port: int = typer.Option(
+        default_config.frontend.port,
+        help="Specify a frontend port.",
+    ),
+    socket_host: str = typer.Option(
+        default_config.socket.host,
+        help="Specify a socket host.",
+    ),
+    socket_port: int = typer.Option(
+        default_config.socket.port,
+        help="Specify a socket port.",
+    ),
+):
+    """Initialize HardPy tests directory.
+
+    Args:
+        tests_dir (str | None): Tests directory. Current directory + `tests` by default
+        create_database (bool): Flag to create database
+        database_user (str): Database user name
+        database_password (str): Database password
+        database_host (str): Database host
+        database_port (int): Database port
+        frontend_host (str): Panel operator host
+        frontend_port (int): Panel operator port
+        socket_host (str): Socket host
+        socket_port (int): Socket port
+    """
+    _tests_dir = tests_dir if tests_dir else default_config.tests_dir
+    ConfigManager().init_config(
+        tests_dir=str(_tests_dir),
+        database_user=database_user,
+        database_password=database_password,
+        database_host=database_host,
+        database_port=database_port,
+        frontend_host=frontend_host,
+        frontend_port=frontend_port,
+        socket_host=socket_host,
+        socket_port=socket_port,
+    )
+    # create tests directory
+    dir_path = Path(Path.cwd() / _tests_dir)
+    os.makedirs(dir_path, exist_ok=True)
+
+    if create_database:
+        # create database directory
+        os.makedirs(dir_path / "database", exist_ok=True)
+
+    # create hardpy.toml
+    ConfigManager().create_config(dir_path)
+    config = ConfigManager().read_config(dir_path)
+    if not config:
+        print(f"hardpy.toml config by path {dir_path} not detected.")
+        sys.exit()
+
+    template = TemplateGenerator(config)
+
+    files = {}
+
+    if create_database:
+        files[Path(dir_path / "docker-compose.yaml")] = template.docker_compose_yaml
+        files[Path(dir_path / "database" / "couchdb.ini")] = template.couchdb_ini
+
+    files[Path(dir_path / "pytest.ini")] = template.pytest_ini
+    files[Path(dir_path / "test_1.py")] = template.test_1_py
+    files[Path(dir_path / "conftest.py")] = template.conftest_py
+
+    for key, value in files.items():
+        template.create_file(key, value)
+
+    print(f"HardPy project {dir_path.name} initialized successfully.")
+
+
+@cli.command()
+def run(tests_dir: Annotated[Optional[str], typer.Argument()] = None):
+    """Run HardPy server.
+
+    Args:
+        tests_dir (Optional[str]): Test directory. Current directory by default
+    """
+    dir_path = Path.cwd() / tests_dir if tests_dir else Path.cwd()
+    config = ConfigManager().read_config(dir_path)
+
+    if not config:
+        print(f"Config at path {dir_path} not found.")
+        sys.exit()
+
+    print("\nLaunch the HardPy operator panel...")
+    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",
+    )
+
+
+if __name__ == "__main__":
+    cli()

hardpy/cli/template.py

@@ -0,0 +1,220 @@
+# Copyright (c) 2024 Everypin
+# GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from pathlib import Path
+
+from hardpy.common.config import HardpyConfig
+
+docker_compose_yaml = """version: "3.8"
+
+services:
+  couchserver:
+    image: couchdb:3.3.2
+    ports:
+      - "{}:5984"
+    environment:
+      COUCHDB_USER: {}
+      COUCHDB_PASSWORD: {}
+    volumes:
+      - ./database/dbdata:/opt/couchdb/data
+      - ./database/couchdb.ini:/opt/couchdb/etc/local.ini
+"""
+
+couchdb_ini = """; CouchDB Configuration Settings
+
+; Custom settings should be made in this file. They will override settings
+; in default.ini, but unlike changes made to default.ini, this file won't be
+; overwritten on server upgrade.
+
+[couchdb]
+;max_document_size = 4294967296 ; bytes
+;os_process_timeout = 5000
+
+[couch_peruser]
+; If enabled, couch_peruser ensures that a private per-user database
+; exists for each document in _users. These databases are writable only
+; by the corresponding user. Databases are in the following form:
+; userdb-{{hex encoded username}}
+;enable = true
+
+; If set to true and a user is deleted, the respective database gets
+; deleted as well.
+;delete_dbs = true
+
+; Set a default q value for peruser-created databases that is different from
+; cluster / q
+;q = 1
+
+[chttpd]
+;port = {}
+;bind_address = {}
+
+; Options for the MochiWeb HTTP server.
+;server_options = [{{backlog, 128}}, {{acceptor_pool_size, 16}}]
+
+; For more socket options, consult Erlang's module 'inet' man page.
+;socket_options = [{{sndbuf, 262144}}, {{nodelay, true}}]
+
+enable_cors=true
+
+[httpd]
+; NOTE that this only configures the "backend" node-local port, not the
+; "frontend" clustered port. You probably don't want to change anything in
+; this section.
+; Uncomment next line to trigger basic-auth popup on unauthorized requests.
+;WWW-Authenticate = Basic realm="administrator"
+
+; Uncomment next line to set the configuration modification whitelist. Only
+; whitelisted values may be changed via the /_config URLs. To allow the admin
+; to change this value over HTTP, remember to include {{httpd,config_whitelist}}
+; itself. Excluding it from the list would require editing this file to update
+; the whitelist.
+;config_whitelist = [{{httpd,config_whitelist}}, {{log,level}}, {{etc,etc}}]
+
+[cors]
+origins = *
+methods = GET, PUT, POST, HEAD, DELETE
+credentials = true
+headers = accept, authorization, content-type, origin, referer, x-csrf-token
+
+
+[ssl]
+;enable = true
+;cert_file = /full/path/to/server_cert.pem
+;key_file = /full/path/to/server_key.pem
+;password = somepassword
+
+; set to true to validate peer certificates
+;verify_ssl_certificates = false
+
+; Set to true to fail if the client does not send a certificate. Only used if verify_ssl_certificates is true.
+;fail_if_no_peer_cert = false
+
+; Path to file containing PEM encoded CA certificates (trusted
+; certificates used for verifying a peer certificate). May be omitted if
+; you do not want to verify the peer.
+;cacert_file = /full/path/to/cacertf
+
+; The verification fun (optional) if not specified, the default
+; verification fun will be used.
+;verify_fun = {{Module, VerifyFun}}
+
+; maximum peer certificate depth
+;ssl_certificate_max_depth = 1
+
+; Reject renegotiations that do not live up to RFC 5746.
+;secure_renegotiate = true
+
+; The cipher suites that should be supported.
+; Can be specified in erlang format "{{ecdhe_ecdsa,aes_128_cbc,sha256}}"
+; or in OpenSSL format "ECDHE-ECDSA-AES128-SHA256".
+;ciphers = ["ECDHE-ECDSA-AES128-SHA256", "ECDHE-ECDSA-AES128-SHA"]
+
+; The SSL/TLS versions to support
+;tls_versions = [tlsv1, 'tlsv1.1', 'tlsv1.2']
+
+; To enable Virtual Hosts in CouchDB, add a vhost = path directive. All requests to
+; the Virtual Host will be redirected to the path. In the example below all requests
+; to http://example.com/ are redirected to /database.
+; If you run CouchDB on a specific port, include the port number in the vhost:
+; example.com:5984 = /database
+[vhosts]
+;example.com = /database/
+
+; To create an admin account uncomment the '[admins]' section below and add a
+; line in the format 'username = password'. When you next start CouchDB, it
+; will change the password to a hash (so that your passwords don't linger
+; around in plain-text files). You can add more admin accounts with more
+; 'username = password' lines. Don't forget to restart CouchDB after
+; changing this.
+[admins]
+;admin = mysecretpassword
+"""
+
+pytest_ini = """[pytest]
+log_cli = true
+log_cli_level = INFO
+log_cli_format = %%(asctime)s [%%(levelname)s] %%(message)s
+log_cli_date_format = %H:%M:%S
+addopts = --hardpy-pt
+          --hardpy-db-url http://{}:{}@{}:{}/
+          --hardpy-sh {}
+          --hardpy-sp {}
+"""
+
+test_1_py = """import pytest
+import hardpy
+
+
+pytestmark = pytest.mark.module_name("HardPy template")
+
+
+@pytest.mark.case_name("Test 1")
+def test_one():
+    assert True
+"""
+
+conftest_py = """import pytest
+import hardpy
+
+
+def finish_executing():
+    print("Testing completed")
+
+
+@pytest.fixture(scope="session", autouse=True)
+def fill_actions_after_test(post_run_functions: list):
+    post_run_functions.append(finish_executing)
+    yield
+"""
+
+
+class TemplateGenerator:
+    """HardPy template files generator."""
+
+    def __init__(self, config: HardpyConfig):
+        self._config = config
+
+    def create_file(self, file_path: Path, content: str):
+        """Create HardPy template file.
+
+        Args:
+            file_path (Path): file path
+            content (str): file content
+        """
+        with open(file_path, "w") as file:
+            file.write(content)
+
+    @property
+    def docker_compose_yaml(self) -> str:
+        return docker_compose_yaml.format(
+            self._config.database.port,
+            self._config.database.user,
+            self._config.database.password,
+        )
+
+    @property
+    def couchdb_ini(self) -> str:
+        return couchdb_ini.format(
+            self._config.database.port,
+            self._config.database.host,
+        )
+
+    @property
+    def pytest_ini(self) -> str:
+        return pytest_ini.format(
+            self._config.database.user,
+            self._config.database.password,
+            self._config.database.host,
+            self._config.database.port,
+            self._config.socket.host,
+            self._config.socket.port,
+        )
+
+    @property
+    def test_1_py(self) -> str:  # noqa: WPS114
+        return test_1_py
+
+    @property
+    def conftest_py(self) -> str:
+        return conftest_py

hardpy/common/config.py

@@ -0,0 +1,159 @@
+# 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 pathlib import Path
+
+import rtoml
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+logger = getLogger(__name__)
+
+
+class DatabaseConfig(BaseModel):
+    """Database configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    user: str = "dev"
+    password: str = "dev"
+    host: str = "localhost"
+    port: int = 5984
+
+    def connection_url(self) -> str:
+        """Get database connection url.
+
+        Returns:
+            str: database connection url
+        """
+        credentials = f"{self.user}:{self.password}"
+        uri = f"{self.host}:{str(self.port)}"  # noqa: WPS237
+        return f"http://{credentials}@{uri}/"
+
+
+class FrontendConfig(BaseModel):
+    """Frontend configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    host: str = "localhost"
+    port: int = 8000
+
+
+class SocketConfig(BaseModel):
+    """Socket configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    host: str = "localhost"
+    port: int = 6525
+
+
+class HardpyConfig(BaseModel):
+    """HardPy configuration."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    title: str = "HardPy TOML config"
+    tests_dir: str = "tests"
+    database: DatabaseConfig = DatabaseConfig()
+    frontend: FrontendConfig = FrontendConfig()
+    socket: SocketConfig = SocketConfig()
+
+
+class ConfigManager:
+    """HardPy configuration manager."""
+
+    obj = HardpyConfig()
+    tests_path = Path.cwd()
+
+    @classmethod
+    def init_config(  # noqa: WPS211
+        cls,
+        tests_dir: str,
+        database_user: str,
+        database_password: str,
+        database_host: str,
+        database_port: int,
+        frontend_host: str,
+        frontend_port: int,
+        socket_host: str,
+        socket_port: int,
+    ):
+        """Initialize HardPy configuration.
+
+        Args:
+            tests_dir (str): Tests directory.
+            database_user (str): Database user name.
+            database_password (str): Database password.
+            database_host (str): Database host.
+            database_port (int): Database port.
+            frontend_host (str): Operator panel host.
+            frontend_port (int): Operator panel port.
+            socket_host (str): Socket host.
+            socket_port (int): Socket port.
+        """
+        cls.obj.tests_dir = str(tests_dir)
+        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.socket.host = socket_host
+        cls.obj.socket.port = socket_port
+
+    @classmethod
+    def create_config(cls, parent_dir: Path):
+        """Create HardPy configuration.
+
+        Args:
+            parent_dir (Path): Configuration file parent directory.
+        """
+        with open(parent_dir / "hardpy.toml", "w") as file:
+            file.write(rtoml.dumps(cls.obj.model_dump()))
+
+    @classmethod
+    def read_config(cls, toml_path: Path) -> HardpyConfig | None:
+        """Read HardPy configuration.
+
+        Args:
+            toml_path (Path): hardpy.toml file path.
+
+        Returns:
+            HardpyConfig | None: HardPy configuration
+        """
+        cls.tests_path = toml_path
+        toml_file = toml_path / "hardpy.toml"
+        if not toml_file.exists():
+            logger.error(f"File hardpy.toml not found at path: {toml_file}")
+            return None
+        try:
+            with open(toml_path / "hardpy.toml", "r") as f:
+                cls.obj = HardpyConfig(**rtoml.load(f))
+            return cls.obj
+        except rtoml.TomlParsingError as exc:
+            logger.error(f"Error parsing TOML: {exc}")
+        except rtoml.TomlSerializationError as exc:
+            logger.error(f"Error parsing TOML: {exc}")
+        except ValidationError as exc:
+            logger.error(f"Error parsing TOML: {exc}")
+        return None
+
+    @classmethod
+    def get_config(cls) -> HardpyConfig:
+        """Get HardPy configuration.
+
+        Returns:
+            HardpyConfig: HardPy configuration
+        """
+        return cls.obj
+
+    @classmethod
+    def get_tests_path(cls) -> Path:  # noqa: WPS615
+        """Get tests path.
+
+        Returns:
+            Path: HardPy tests path
+        """
+        return cls.tests_path

hardpy/hardpy_panel/api.py

@@ -2,17 +2,34 @@
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 import os
+import re
+from enum import Enum
+from urllib.parse import unquote
 
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
 
-from hardpy.pytest_hardpy.utils import ConfigData, RunStatus as Status
+from hardpy.common.config import ConfigManager
 from hardpy.pytest_hardpy.pytest_wrapper import PyTestWrapper
 
 app = FastAPI()
 app.state.pytest_wrp = PyTestWrapper()
 
 
+class Status(str, Enum):  # noqa: WPS600
+    """Pytest run status.
+
+    Statuses, that can be returned by HardPy to frontend.
+    """
+
+    STOPPED = "stopped"
+    STARTED = "started"
+    COLLECTED = "collected"
+    BUSY = "busy"
+    READY = "ready"
+    ERROR = "error"
+
+
 @app.get("/api/start")
 def start_pytest():
     """Start pytest subprocess.
@@ -55,12 +72,12 @@ def couch_connection():
     """Get couchdb connection string.
 
     Returns:
-        dict[str, str, str]: couchdb connection string
+        dict[str, str]: couchdb connection string
     """
-    config_data = ConfigData()
+    connection_url = ConfigManager().get_config().database.connection_url()
 
     return {
-        "connection_str": config_data.connection_string,
+        "connection_str": connection_url,
     }
 
 
@@ -74,13 +91,39 @@ def confirm_dialog_box(dialog_box_output: str):
     Returns:
         dict[str, RunStatus]: run status
     """
-    if app.state.pytest_wrp.confirm_dialog_box(dialog_box_output):
+    hex_base = 16
+    unquoted_string = unquote(dialog_box_output)
+    decoded_string = re.sub(
+        "%([0-9a-fA-F]{2})",
+        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}
+
+
+@app.post("/api/confirm_operator_msg/{is_msg_visible}")
+def confirm_operator_msg(is_msg_visible: bool):
+    """Confirm operator msg.
+
+    Args:
+        is_msg_visible (bool): is operator message is visible
+
+    Returns:
+        dict[str, RunStatus]: run status
+    """
+    if app.state.pytest_wrp.send_data(str(is_msg_visible)):
         return {"status": Status.BUSY}
     return {"status": Status.ERROR}
 
 
 app.mount(
     "/",
-    StaticFiles(directory=(os.path.dirname(__file__)) + "/frontend/dist", html=True),
+    StaticFiles(
+        directory=(os.path.dirname(__file__)) + "/frontend/dist",  # noqa: WPS336
+        html=True,
+    ),
     name="static",
 )

hardpy/hardpy_panel/frontend/dist/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "/static/css/main.e8a862f1.css",
-    "main.js": "/static/js/main.da686f40.js",
+    "main.js": "/static/js/main.7c954faf.js",
     "blueprint-icons-all-paths-loader.js": "/static/js/blueprint-icons-all-paths-loader.0aa89747.chunk.js",
     "blueprint-icons-split-paths-by-size-loader.js": "/static/js/blueprint-icons-split-paths-by-size-loader.52a072d3.chunk.js",
     "static/js/808.ce070002.chunk.js": "/static/js/808.ce070002.chunk.js",
@@ -21,7 +21,7 @@
     "static/media/logo_smol.png": "/static/media/logo_smol.5b16f92447a4a9e80331.png",
     "index.html": "/index.html",
     "main.e8a862f1.css.map": "/static/css/main.e8a862f1.css.map",
-    "main.da686f40.js.map": "/static/js/main.da686f40.js.map",
+    "main.7c954faf.js.map": "/static/js/main.7c954faf.js.map",
     "blueprint-icons-all-paths-loader.0aa89747.chunk.js.map": "/static/js/blueprint-icons-all-paths-loader.0aa89747.chunk.js.map",
     "blueprint-icons-split-paths-by-size-loader.52a072d3.chunk.js.map": "/static/js/blueprint-icons-split-paths-by-size-loader.52a072d3.chunk.js.map",
     "808.ce070002.chunk.js.map": "/static/js/808.ce070002.chunk.js.map",
@@ -31,6 +31,6 @@
   },
   "entrypoints": [
     "static/css/main.e8a862f1.css",
-    "static/js/main.da686f40.js"
+    "static/js/main.7c954faf.js"
   ]
 }

hardpy/hardpy_panel/frontend/dist/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>HardPy Operator Panel</title><script defer="defer" src="/static/js/main.da686f40.js"></script><link href="/static/css/main.e8a862f1.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/favicon.ico"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="Web site created using create-react-app"/><link rel="apple-touch-icon" href="/logo192.png"/><link rel="manifest" href="/manifest.json"/><title>HardPy Operator Panel</title><script defer="defer" src="/static/js/main.7c954faf.js"></script><link href="/static/css/main.e8a862f1.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>