hardpy 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

hardpy/pytest_hardpy/db/base_store.py

@@ -36,19 +36,29 @@ class BaseStore(BaseConnector):
         """
         return glom(self._doc, key)
 
-    def set_value(self, key: str, value):
-        """Set a value in the state store."""
-        assign(self._doc, key, value)
+    def update_doc(self, key: str, value):
+        """Update document.
+
+        HardPy collecting uses a simple key without dots.
+        Assign is used to update a document.
+        Assign is a longer function.
+
+        Args:
+            key (str): document key
+            value: document value
+        """
+        if "." in key:
+            assign(self._doc, key, value)
+        else:
+            self._doc[key] = value
+
+    def update_db(self):
+        """Update database by current document."""
         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)
+        except Conflict:
+            self._doc["_rev"] = self._db.get(self._doc_id)["_rev"]
+            self._doc = self._db.save(self._doc)
 
     def get_document(self) -> ModelMetaclass:
         """Get document by schema.

hardpy/pytest_hardpy/plugin.py

@@ -9,6 +9,7 @@ from platform import system
 
 from natsort import natsorted
 from pytest import (
+    skip,
     exit,
     TestReport,
     Item,
@@ -27,6 +28,7 @@ from hardpy.pytest_hardpy.utils import (
     ProgressCalculator,
     ConfigData,
 )
+from hardpy.pytest_hardpy.utils.node_info import TestDependencyInfo
 
 
 def pytest_addoption(parser: Parser):
@@ -40,6 +42,7 @@ def pytest_addoption(parser: Parser):
     parser.addoption("--hardpy-pt", action="store_true", default=False, help="enable pytest-hardpy plugin")  # noqa: E501
     # fmt: on
 
+
 # Bootstrapping hooks
 def pytest_load_initial_conftests(early_config, parser, args):
     if "--hardpy-pt" in args:
@@ -57,6 +60,7 @@ class HardpyPlugin(object):
         self._progress = ProgressCalculator()
         self._results = {}
         self._post_run_functions: list[Callable] = []
+        self._dependencies = {}
 
         if system() == "Linux":
             signal.signal(signal.SIGTERM, self._stop_handler)
@@ -64,7 +68,6 @@ class HardpyPlugin(object):
             signal.signal(signal.SIGBREAK, self._stop_handler)
         self._log = getLogger(__name__)
 
-
     # Initialization hooks
 
     def pytest_configure(self, config: Config):
@@ -77,6 +80,7 @@ class HardpyPlugin(object):
 
         config.addinivalue_line("markers", "case_name")
         config.addinivalue_line("markers", "module_name")
+        config.addinivalue_line("markers", "dependency")
 
         # must be init after config data is set
         self._reporter = HookReporter()
@@ -92,6 +96,8 @@ class HardpyPlugin(object):
             return
         status = self._get_run_status(exitstatus)
         self._reporter.finish(status)
+        self._reporter.update_db_by_doc()
+        self._reporter.compact_all()
 
         # call post run methods
         if self._post_run_functions:
@@ -107,6 +113,7 @@ class HardpyPlugin(object):
         self._reporter.init_doc(str(PurePath(config.rootpath).name))
 
         nodes = {}
+        modules = set()
 
         session.items = natsorted(
             session.items,
@@ -115,18 +122,26 @@ class HardpyPlugin(object):
         for item in session.items:
             if item.parent is None:
                 continue
-            node_info = NodeInfo(item)
+            try:
+                node_info = NodeInfo(item)
+            except ValueError:
+                error_msg = f"Error creating NodeInfo for item: {item}\n"
+                exit(error_msg, 1)
 
             self._init_case_result(node_info.module_id, node_info.case_id)
-
             if node_info.module_id not in nodes:
                 nodes[node_info.module_id] = [node_info.case_id]
             else:
                 nodes[node_info.module_id].append(node_info.case_id)
 
             self._reporter.add_case(node_info)
-            self._reporter.set_module_status(node_info.module_id, TestStatus.READY)
+
+            self._add_dependency(node_info, nodes)
+            modules.add(node_info.module_id)
+        for module_id in modules:
+            self._reporter.set_module_status(module_id, TestStatus.READY)
         self._reporter.update_node_order(nodes)
+        self._reporter.update_db_by_doc()
 
     # Test running (runtest) hooks
 
@@ -139,6 +154,7 @@ class HardpyPlugin(object):
 
         # testrun entrypoint
         self._reporter.start()
+        self._reporter.update_db_by_doc()
 
     def pytest_runtest_setup(self, item: Item):
         """Call before each test setup phase."""
@@ -148,6 +164,8 @@ class HardpyPlugin(object):
 
         node_info = NodeInfo(item)
 
+        self._handle_dependency(node_info)
+
         self._reporter.set_module_status(node_info.module_id, TestStatus.RUN)
         self._reporter.set_module_start_time(node_info.module_id)
         self._reporter.set_case_status(
@@ -159,6 +177,7 @@ class HardpyPlugin(object):
             node_info.module_id,
             node_info.case_id,
         )
+        self._reporter.update_db_by_doc()
 
     # Reporting hooks
 
@@ -188,6 +207,7 @@ class HardpyPlugin(object):
 
         if None not in self._results[module_id].values():
             self._collect_module_result(module_id)
+        self._reporter.update_db_by_doc()
 
     # Fixture
 
@@ -250,3 +270,47 @@ class HardpyPlugin(object):
             index = report.find("\nE")
             return report[:index]
         return None
+
+    def _handle_dependency(self, node_info: NodeInfo):
+        dependency = self._dependencies.get(
+            TestDependencyInfo(
+                node_info.module_id,
+                node_info.case_id,
+            )
+        )
+        if dependency and self._is_dependency_failed(dependency):
+            self._log.debug(f"Skipping test due to dependency: {dependency}")
+            self._results[node_info.module_id][node_info.case_id] = TestStatus.SKIPPED
+            skip(f"Test {node_info.module_id}::{node_info.case_id} is skipped")
+
+    def _is_dependency_failed(self, dependency) -> bool:
+        if isinstance(dependency, TestDependencyInfo):
+            incorrect_status = {
+                TestStatus.FAILED,
+                TestStatus.SKIPPED,
+                TestStatus.ERROR,
+            }
+            module_id, case_id = dependency
+            if case_id is not None:
+                return self._results[module_id][case_id] in incorrect_status
+            return any(
+                status in incorrect_status
+                for status in set(self._results[module_id].values())
+            )
+        return False
+
+    def _add_dependency(self, node_info, nodes):
+        dependency = node_info.dependency
+        if dependency is None or dependency == "":
+            return
+        module_id, case_id = dependency
+        if module_id not in nodes:
+            error_message = f"Error: Module dependency '{dependency}' not found."
+            exit(error_message, 1)
+        elif case_id not in nodes[module_id] and case_id is not None:
+            error_message = f"Error: Case dependency '{dependency}' not found."
+            exit(error_message, 1)
+
+        self._dependencies[
+            TestDependencyInfo(node_info.module_id, node_info.case_id)
+        ] = dependency

hardpy/pytest_hardpy/pytest_call.py

@@ -52,7 +52,8 @@ def set_dut_info(info: dict):
     reporter = RunnerReporter()
     for dut_key, dut_value in info.items():
         key = reporter.generate_key(DF.DUT, DF.INFO, dut_key)
-        reporter.set_db_value(key, dut_value)
+        reporter.set_doc_value(key, dut_value)
+    reporter.update_db_by_doc()
 
 
 def set_dut_serial_number(serial_number: str):
@@ -68,7 +69,8 @@ def set_dut_serial_number(serial_number: str):
     key = reporter.generate_key(DF.DUT, DF.SERIAL_NUMBER)
     if reporter.get_field(key):
         raise DuplicateSerialNumberError
-    reporter.set_db_value(key, serial_number)
+    reporter.set_doc_value(key, serial_number)
+    reporter.update_db_by_doc()
 
 
 def set_stand_info(info: dict):
@@ -80,7 +82,8 @@ def set_stand_info(info: dict):
     reporter = RunnerReporter()
     for stand_key, stand_value in info.items():
         key = reporter.generate_key(DF.TEST_STAND, stand_key)
-        reporter.set_db_value(key, stand_value)
+        reporter.set_doc_value(key, stand_value)
+    reporter.update_db_by_doc()
 
 
 def set_message(msg: str, msg_key: Optional[str] = None) -> None:
@@ -111,7 +114,8 @@ def set_message(msg: str, msg_key: Optional[str] = None) -> None:
 
     msgs[msg_key] = msg
 
-    reporter.set_db_value(key, msgs)
+    reporter.set_doc_value(key, msgs)
+    reporter.update_db_by_doc()
 
 
 def set_case_artifact(data: dict):
@@ -134,7 +138,8 @@ def set_case_artifact(data: dict):
             DF.ARTIFACT,
             stand_key,
         )
-        reporter.set_db_value(key, stand_value, is_statestore=False)
+        reporter.set_doc_value(key, stand_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_module_artifact(data: dict):
@@ -155,7 +160,8 @@ def set_module_artifact(data: dict):
             DF.ARTIFACT,
             artifact_key,
         )
-        reporter.set_db_value(key, artifact_value, is_statestore=False)
+        reporter.set_doc_value(key, artifact_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_run_artifact(data: dict):
@@ -173,7 +179,8 @@ def set_run_artifact(data: dict):
             DF.ARTIFACT,
             artifact_key,
         )
-        reporter.set_db_value(key, artifact_value, is_statestore=False)
+        reporter.set_doc_value(key, artifact_value, runstore_only=True)
+    reporter.update_db_by_doc()
 
 
 def set_driver_info(drivers: dict) -> None:
@@ -192,7 +199,8 @@ def set_driver_info(drivers: dict) -> None:
             DF.DRIVERS,
             driver_name,
         )
-        reporter.set_db_value(key, driver_data)
+        reporter.set_doc_value(key, driver_data)
+    reporter.update_db_by_doc()
 
 
 def _get_current_test() -> CurrentTestInfo:

hardpy/pytest_hardpy/reporter/base.py

@@ -14,21 +14,39 @@ class BaseReporter(object):
         self._runstore = RunStore()
         self._log = getLogger(__name__)
 
-    def set_db_value(self, key: str, value, is_statestore=True, is_runstore=True):
-        """Set value to database.
+    def set_doc_value(
+        self, key: str, value, runstore_only=False, statestore_only=False
+    ):
+        """Set value to the document.
+
+        Update a document without writing to the database.
 
         Args:
-            key (str): database key
-            value (_type_): database value
-            is_statestore (bool, optional): indicates whether data should
-                                             be written to StateStore. Defaults to True.
-            is_runstore (bool, optional): indicates whether data should
-                                            be written to RunStore. Defaults to True.
+            key (str): document key
+            value: document value
+            runstore_only (bool, optional): indicates whether data should
+                                             be written to RunStore. Defaults to True.
+            statestore_only (bool, optional): indicates whether data should
+                                            be written to StateStore. Defaults to True.
+
+        Raises:
+            ValueError: if both runstore_only and statestore_only are True
         """
-        if is_statestore:
-            self._statestore.set_value(key, value)
-        if is_runstore:
-            self._runstore.set_value(key, value)
+        if runstore_only and statestore_only:
+            raise ValueError("Both runstore_only and statestore_only cannot be True")
+        if runstore_only:
+            self._runstore.update_doc(key, value)
+            return
+        if statestore_only:
+            self._statestore.update_doc(key, value)
+            return
+        self._runstore.update_doc(key, value)
+        self._statestore.update_doc(key, value)
+
+    def update_db_by_doc(self):
+        """Update database by current document."""
+        self._statestore.update_db()
+        self._runstore.update_db()
 
     def generate_key(self, *args) -> str:
         """Generate key for database.

hardpy/pytest_hardpy/reporter/hook_reporter.py

@@ -25,23 +25,23 @@ class HookReporter(BaseReporter):
         Args:
             doc_name (str): test run name
         """
-        self.set_db_value(DF.NAME, doc_name)
-        self.set_db_value(DF.STATUS, TestStatus.READY)
-        self.set_db_value(DF.START_TIME, None)
-        self.set_db_value(DF.TIMEZONE, None)
-        self.set_db_value(DF.STOP_TIME, None)
-        self.set_db_value(DF.PROGRESS, 0)
-        self.set_db_value(DF.DRIVERS, {})
-        self.set_db_value(DF.ARTIFACT, {}, is_statestore=False)
+        self.set_doc_value(DF.NAME, doc_name)
+        self.set_doc_value(DF.STATUS, TestStatus.READY)
+        self.set_doc_value(DF.START_TIME, None)
+        self.set_doc_value(DF.TIMEZONE, None)
+        self.set_doc_value(DF.STOP_TIME, None)
+        self.set_doc_value(DF.PROGRESS, 0)
+        self.set_doc_value(DF.DRIVERS, {})
+        self.set_doc_value(DF.ARTIFACT, {}, runstore_only=True)
 
     def start(self):
         """Start test."""
         self._log.debug("Starting test run.")
         start_time = int(time())
-        self.set_db_value(DF.START_TIME, start_time)
-        self.set_db_value(DF.STATUS, TestStatus.RUN)
-        self.set_db_value(DF.TIMEZONE, tzname)  # noqa: WPS432
-        self.set_db_value(DF.PROGRESS, 0)
+        self.set_doc_value(DF.START_TIME, start_time)
+        self.set_doc_value(DF.STATUS, TestStatus.RUN)
+        self.set_doc_value(DF.TIMEZONE, tzname)  # noqa: WPS432
+        self.set_doc_value(DF.PROGRESS, 0)
 
     def finish(self, status: RunStatus):
         """Finish test.
@@ -50,15 +50,11 @@ class HookReporter(BaseReporter):
         """
         self._log.debug("Finishing test run.")
         stop_time = int(time())
-        self.set_db_value(DF.STOP_TIME, stop_time)
-        self.set_db_value(DF.STATUS, status)
-
-        if self._statestore.get_document():
-            self._log.debug("Report StateStore has been successfully validated.")
-
-        if self._runstore.get_document():
-            self._log.debug("Report RunStore has been successfully validated.")
+        self.set_doc_value(DF.STOP_TIME, stop_time)
+        self.set_doc_value(DF.STATUS, status)
 
+    def compact_all(self):
+        """Compact all databases"""
         self._statestore.compact()
         self._runstore.compact()
 
@@ -68,7 +64,7 @@ class HookReporter(BaseReporter):
         Args:
             progress (int): test progress
         """
-        self.set_db_value(DF.PROGRESS, progress)
+        self.set_doc_value(DF.PROGRESS, progress)
 
     def set_assertion_msg(self, module_id: str, case_id: str, msg: str | None):
         """Set case assertion message.
@@ -81,7 +77,7 @@ class HookReporter(BaseReporter):
         key = self.generate_key(
             DF.MODULES, module_id, DF.CASES, case_id, DF.ASSERTION_MSG
         )
-        self.set_db_value(key, msg)
+        self.set_doc_value(key, msg)
 
     def add_case(self, node_info: NodeInfo):
         """Add test case to document.
@@ -90,18 +86,15 @@ class HookReporter(BaseReporter):
             node_info (NodeInfo): node info
         """
         key = DF.MODULES
+
         item_statestore = self._statestore.get_field(key)
         item_runstore = self._runstore.get_field(key)
 
-        new_item_statestore = self._init_case(item_statestore, node_info)
-        new_item_runstore = self._init_case(
-            item_runstore,
-            node_info,
-            is_use_artifact=True,
-        )
+        self._init_case(item_statestore, node_info)
+        self._init_case(item_runstore, node_info, is_use_artifact=True)
 
-        self.set_db_value(key, new_item_statestore, is_runstore=False)
-        self.set_db_value(key, new_item_runstore, is_statestore=False)
+        self.set_doc_value(key, item_statestore, statestore_only=True)
+        self.set_doc_value(key, item_runstore, runstore_only=True)
 
     def set_case_status(self, module_id: str, case_id: str, status: TestStatus):
         """Set test case status.
@@ -112,7 +105,7 @@ class HookReporter(BaseReporter):
             status (TestStatus): test case status
         """
         key = self.generate_key(DF.MODULES, module_id, DF.CASES, case_id, DF.STATUS)
-        self.set_db_value(key, status)
+        self.set_doc_value(key, status)
 
     def set_case_start_time(self, module_id: str, case_id: str):
         """Set test case start_time.
@@ -142,7 +135,7 @@ class HookReporter(BaseReporter):
             status (TestStatus): test module status
         """
         key = self.generate_key(DF.MODULES, module_id, DF.STATUS)
-        self.set_db_value(key, status)
+        self.set_doc_value(key, status)
 
     def set_module_start_time(self, module_id: str):
         """Set test module status.
@@ -175,16 +168,16 @@ class HookReporter(BaseReporter):
         rm_outdated_nodes = self._remove_outdate_node(old_modules, modules_copy, nodes)
         updated_case_order = self._update_case_order(rm_outdated_nodes, nodes)
         updated_module_order = self._update_module_order(updated_case_order)
-        self.set_db_value(key, updated_module_order, is_runstore=False)
+        self.set_doc_value(key, updated_module_order, statestore_only=True)
 
     def _set_time(self, key: str):
         current_time = self._statestore.get_field(key)
         if current_time is None:
-            self.set_db_value(key, int(time()))
+            self.set_doc_value(key, int(time()))
 
     def _init_case(
         self, item: dict, node_info: NodeInfo, is_use_artifact: bool = False
-    ) -> dict:
+    ):
         module_default = {  # noqa: WPS204
             DF.STATUS: TestStatus.READY,
             DF.NAME: self._get_module_name(node_info),
@@ -216,8 +209,6 @@ class HookReporter(BaseReporter):
             case_default[DF.ARTIFACT] = {}
         item[node_info.module_id][DF.CASES][node_info.case_id] = case_default
 
-        return item
-
     def _remove_outdate_node(
         self, old_modules: dict, new_modules: dict, nodes: dict
     ) -> dict:

hardpy/pytest_hardpy/utils/node_info.py

@@ -1,12 +1,24 @@
 # Copyright (c) 2024 Everypin
 # GNU General Public License v3.0 (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
 
+import re
 from logging import getLogger
 from pathlib import Path
+from typing import NamedTuple
 
 from pytest import Item, Mark
 
 
+class TestDependencyInfo(NamedTuple):
+    """Test info."""
+
+    def __repr__(self) -> str:
+        return f"Dependency: {self.module_id}::{self.case_id}"
+
+    module_id: str
+    case_id: str | None
+
+
 class NodeInfo(object):
     """Test node info."""
 
@@ -22,25 +34,59 @@ class NodeInfo(object):
             item.parent.own_markers,
             "module_name",
         )
+
+        self._dependency = self._get_dependency_info(
+            item.own_markers + item.parent.own_markers
+        )
+
         self._module_id = Path(item.parent.nodeid).stem
         self._case_id = item.name
 
     @property
     def module_id(self):
+        """Get module id.
+
+        Returns:
+            str: module id
+        """
         return self._module_id
 
     @property
     def case_id(self):
+        """Get case id.
+
+        Returns:
+            str: case id
+        """
         return self._case_id
 
     @property
     def module_name(self):
+        """Get module name.
+
+        Returns:
+            str: module name
+        """
         return self._module_name
 
     @property
     def case_name(self):
+        """Get case name.
+
+        Returns:
+            str: case name
+        """
         return self._case_name
 
+    @property
+    def dependency(self):
+        """Get dependency information.
+
+        Returns:
+            TestDependencyInfo | str: Parsed dependency information.
+        """
+        return self._dependency
+
     def _get_human_name(self, markers: list[Mark], marker_name: str) -> str:
         """Get human name from markers.
 
@@ -57,3 +103,23 @@ class NodeInfo(object):
                     return marker.args[0]
 
         return ""
+
+    def _get_dependency_info(self, markers: list[Mark]) -> TestDependencyInfo | str:
+        """Extract and parse dependency information.
+
+        Args:
+            markers (list[Mark]): item markers list
+            marker_name (str): marker name
+
+        Returns:
+            TestDependencyInfo | str | None: Parsed dependency information.
+        """
+        dependency_value = self._get_human_name(markers, "dependency")
+        dependency_data = re.search(r"(\w+)::(\w+)", dependency_value)
+        if dependency_data:
+            return TestDependencyInfo(*dependency_data.groups())
+        elif re.search(r"^\w+$", dependency_value):
+            return TestDependencyInfo(dependency_value, None)
+        elif dependency_data is None and dependency_value == "":
+            return ""
+        raise ValueError

{hardpy-0.2.0.dist-info → hardpy-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hardpy
-Version: 0.2.0
+Version: 0.3.0
 Summary: HardPy library for device testing
 Project-URL: repository, https://github.com/everypindevices/hardpy
 Author: Everypin
@@ -84,6 +84,7 @@ For Windows, follow the instructions from the
 [documentation](https://everypinio.github.io/hardpy/documentation/database/#couchdb-instance).
 
 Launch CouchDB with Docker.
+The Docker version must be 24.0.0 or higher.
 Create `couchdb.ini` file:
 
 ```ini
@@ -103,6 +104,12 @@ Run the Docker container from folder with couchdb.ini file:
 docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v ./couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3
 ```
 
+Command for Windows:
+
+```bash
+docker run --rm --name couchdb -p 5984:5984 -e COUCHDB_USER=dev -e COUCHDB_PASSWORD=dev -v .\couchdb.ini:/opt/couchdb/etc/local.ini couchdb:3.3.2
+```
+
 #### Test steps
 
 Add simple test to `tests` folder

{hardpy-0.2.0.dist-info → hardpy-0.3.0.dist-info}/RECORD

@@ -36,20 +36,20 @@ hardpy/hardpy_panel/frontend/dist/static/media/blueprint-icons-20.afbadb627d43b7
 hardpy/hardpy_panel/frontend/dist/static/media/blueprint-icons-20.e857f5a5132b8bfa71a1.woff,sha256=mQZTxE1PyyAL16VWuASOvXlZFwuI4aCPvbrhfgpdIdU,55356
 hardpy/hardpy_panel/frontend/dist/static/media/logo_smol.5b16f92447a4a9e80331.png,sha256=E4K7drvhJCg9HcTpRihOXZhVJVBZ7-W97Se-3tDb46o,14485
 hardpy/pytest_hardpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hardpy/pytest_hardpy/plugin.py,sha256=_qVu3F54qikloIGhV6Enb0-m2Oy6h_VBOo4jwNzOLdc,8415
-hardpy/pytest_hardpy/pytest_call.py,sha256=wyMDt4AwQC4qg6pYnevQv7FIhIvHNYreQdU1kEenqdY,5910
+hardpy/pytest_hardpy/plugin.py,sha256=lL3ZNVVSlS7VzpVDiF_SWbnbFBbK9vXtD6JZwqBoObA,10973
+hardpy/pytest_hardpy/pytest_call.py,sha256=CrbAw_W6A1HU06xIcylivgNKVUzGoo0B0ikNqflHbDo,6171
 hardpy/pytest_hardpy/pytest_wrapper.py,sha256=bC8ROwAEjo3TpXpNtHXUS-C_fpIyeCPtgfGBSZ82aI8,3554
 hardpy/pytest_hardpy/db/__init__.py,sha256=MxDufncz0zgRAxrndvPXXW4NrU7rRP7MzIrR7S5Cwwo,558
 hardpy/pytest_hardpy/db/base_connector.py,sha256=7KUgPY-GmAo8MFN4OFpG5y3WH1xjohRnpeQ1gxQF1tg,751
 hardpy/pytest_hardpy/db/base_server.py,sha256=uBnq5zGkzEIq_EGzLw0C8kfDEDvQyN52Y6L41KKL9FQ,397
-hardpy/pytest_hardpy/db/base_store.py,sha256=iKh8qN-sPu79Ogp5857TR0t5RbGssC8V7iFAZAF5aFU,2504
+hardpy/pytest_hardpy/db/base_store.py,sha256=DiYaBOwufEOdtDpo9dUb3ZaZ7-c1FInAWjLpUXSEFHA,2668
 hardpy/pytest_hardpy/db/const.py,sha256=ffYW54TP0aNF5LhW3g_2G5kVuvqAMWfuJqNDzWZg2nI,618
 hardpy/pytest_hardpy/db/runstore.py,sha256=50amoTIO7OTqd5Ks1_7uTzqjCldLpTapkxbIQOgj1sQ,1023
 hardpy/pytest_hardpy/db/schema.py,sha256=iIclTudP0tauTWLYiEW9MMlvBfuWOteA7eRzDU5gKwI,6859
 hardpy/pytest_hardpy/db/statestore.py,sha256=1BUfA4oqG4vx7z5v_uUYi_Un6YA769JeuShxDicrl9Q,636
 hardpy/pytest_hardpy/reporter/__init__.py,sha256=RONapygH3c_FyXokAlyCVJXGV2cV_jCYDxLymvvA1uE,322
-hardpy/pytest_hardpy/reporter/base.py,sha256=kHYSLVxiq5Fyf4V-xGtgfOS3nImN1j5c13zcvqK1sq0,1343
-hardpy/pytest_hardpy/reporter/hook_reporter.py,sha256=_7mM3B0U_vsuGGAKuX7jtuS045XVRouCeF0Q8uSUAwY,10181
+hardpy/pytest_hardpy/reporter/base.py,sha256=M-lwli64ty9FW8HlGEpUyoFsZv48tyNgzPjCWVUrATY,1941
+hardpy/pytest_hardpy/reporter/hook_reporter.py,sha256=TE6IzQVH10ce8JXWtep80kgyVOicU02C75FDpV6NfSQ,9895
 hardpy/pytest_hardpy/reporter/runner_reporter.py,sha256=NXkBIoERqmLI-GYtHavmOWC5t6NIpcAE-NECrUKIAJs,827
 hardpy/pytest_hardpy/result/__init__.py,sha256=NMeCGx3yh8ds9VpaUpuNFDxbwgYFq3e-o7W6rYIv8uI,346
 hardpy/pytest_hardpy/result/couchdb_config.py,sha256=QZryfA2QoHIjzbVT3OAD76DCNppCghtRWdZMZ5v7KhY,611
@@ -61,11 +61,11 @@ hardpy/pytest_hardpy/utils/__init__.py,sha256=IeOr27pgzvMolQtEXJxODJKNdQAFww8Ejj
 hardpy/pytest_hardpy/utils/config_data.py,sha256=F8khHsvkEsJjDnoHeLjI0rgsAfETN7nSlEP2snf2kio,990
 hardpy/pytest_hardpy/utils/const.py,sha256=rjW1Rzhe2vCr8GeQqeN_pafepGDYhjhY4u1VfTOVI6U,625
 hardpy/pytest_hardpy/utils/exception.py,sha256=5GnVkOchSPDEXaOXaruO0YzKXoY7b3Y5mVU5-51ZKRg,457
-hardpy/pytest_hardpy/utils/node_info.py,sha256=9aK8X-lNrY3unjHAR-DBS6GFKyo7rEoDH-CTy_WGdFw,1437
+hardpy/pytest_hardpy/utils/node_info.py,sha256=VnEbhKBNAL5xpuFtJTCg90TmkjkFCQA59F5W2RcOlx4,3157
 hardpy/pytest_hardpy/utils/progress_calculator.py,sha256=r0qb3p6_yDIyLeCshF3Ceo5pCzd3BoTahL4rCD2oMNw,1041
 hardpy/pytest_hardpy/utils/singleton.py,sha256=C8cgRDydnG2b5dcN1LCLw4aM-AUMAvJc1W39mTkNWlQ,614
-hardpy-0.2.0.dist-info/METADATA,sha256=ZyxZaCBvj2QYXPcwWFvrEvZaOGPKeK1kY8VByYTEtCY,3870
-hardpy-0.2.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-hardpy-0.2.0.dist-info/entry_points.txt,sha256=q73g5GfznSUpjkayi0SV4uaAtrf7D-7rmDoWoEZmZe0,120
-hardpy-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-hardpy-0.2.0.dist-info/RECORD,,
+hardpy-0.3.0.dist-info/METADATA,sha256=lWSZtZSy7b_PISotSgTw3lyM1X2uJPj0dVmOfI2A9N8,4096
+hardpy-0.3.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+hardpy-0.3.0.dist-info/entry_points.txt,sha256=q73g5GfznSUpjkayi0SV4uaAtrf7D-7rmDoWoEZmZe0,120
+hardpy-0.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+hardpy-0.3.0.dist-info/RECORD,,