cucu 1.2.4__py3-none-any.whl → 1.2.5__py3-none-any.whl

cucu/cli/core.py

@@ -30,10 +30,11 @@ from cucu import (
     reporter,
 )
 from cucu.cli import thread_dumper
-from cucu.cli.run import behave, behave_init, write_run_details
+from cucu.cli.run import behave, behave_init, create_run
 from cucu.cli.steps import print_human_readable_steps, print_json_steps
 from cucu.config import CONFIG
 from cucu.lint import linter
+from cucu.utils import generate_short_id
 
 # will start coverage tracking once COVERAGE_PROCESS_START is set
 coverage.process_startup()
@@ -297,8 +298,12 @@ def run(
     if record_env_vars:
         os.environ["CUCU_RECORD_ENV_VARS"] = "true"
 
+    os.environ["CUCU_RUN_ID"] = CONFIG["CUCU_RUN_ID"] = generate_short_id()
+    CONFIG["WORKER_RUN_ID"] = "parent"
     if not dry_run:
-        write_run_details(results, filepath)
+        create_run(results, filepath)
+
+    CONFIG.snapshot("core_run")
 
     try:
         if workers is None or workers == 1:
@@ -486,6 +491,8 @@ def run(
                         "there are failures, see above for details"
                     )
     finally:
+        CONFIG.restore(with_pop=True)
+
         if dumper is not None:
             dumper.stop()
 
@@ -499,7 +506,10 @@ def run(
 
 
 def _generate_report(
-    filepath: str, output: str, only_failures: False, junit: str | None = None
+    results_dir: str,
+    output: str,
+    only_failures: False,
+    junit: str | None = None,
 ):
     """
     helper method to handle report generation so it can be used by the `cucu report`
@@ -508,7 +518,7 @@ def _generate_report(
 
 
     parameters:
-        filepath(string): the results directory containing the previous test run
+        results_dir(string): the results directory containing the previous test run
         output(string): the directory where we'll generate the report
         only_failures(bool, optional): if only report failures. The default is False.
         junit(str|None, optional): the directory of the JUnit files. The default if None.
@@ -519,7 +529,7 @@ def _generate_report(
     os.makedirs(output)
 
     report_location = reporter.generate(
-        filepath, output, only_failures=only_failures
+        results_dir, output, only_failures=only_failures
     )
     print(f"HTML test report at {report_location}")
 

cucu/cli/run.py

@@ -4,6 +4,7 @@ import os
 import socket
 import sys
 from datetime import datetime
+from pathlib import Path
 
 from cucu import (
     behave_tweaks,
@@ -16,13 +17,12 @@ from cucu.page_checks import init_page_checks
 
 
 def get_feature_name(file_path):
-    with open(file_path, "r") as file:
-        text = file.read()
-        lines = text.split("\n")
-        for line in lines:
-            if "Feature:" in line:
-                feature_name = line.replace("Feature:", "").strip()
-                return feature_name
+    text = Path(file_path).read_text(encoding="utf8")
+    lines = text.split("\n")
+    for line in lines:
+        if "Feature:" in line:
+            feature_name = line.replace("Feature:", "").strip()
+            return feature_name
 
 
 def behave_init(filepath="features"):
@@ -104,7 +104,7 @@ def behave(
     run_json_filename = "run.json"
     if redirect_output:
         feature_name = get_feature_name(filepath)
-        run_json_filename = f"{feature_name + '-run.json'}"
+        run_json_filename = f"{feature_name}-run.json"
 
     if dry_run:
         args += [
@@ -120,7 +120,7 @@ def behave(
             "--no-logcapture",
             # generate a JSON file containing the exact details of the whole run
             "--format=cucu.formatter.json:CucuJSONFormatter",
-            f"--outfile={results}/{run_json_filename}",
+            f"--outfile={Path(results) / run_json_filename}",
             # console formatter
             "--format=cucu.formatter.cucu:CucuFormatter",
             f"--logging-level={os.environ['CUCU_LOGGING_LEVEL'].upper()}",
@@ -148,8 +148,8 @@ def behave(
     try:
         if redirect_output:
             feature_name = get_feature_name(filepath)
-            log_filename = f"{feature_name + '.log'}"
-            log_filepath = os.path.join(results, log_filename)
+            log_filename = f"{feature_name}.log"
+            log_filepath = Path(results) / log_filename
 
             CONFIG["__CUCU_PARENT_STDOUT"] = sys.stdout
 
@@ -161,7 +161,7 @@ def behave(
             # provide progress feedback on screen
             register_before_retry_hook(retry_progress)
 
-            with open(log_filepath, "w", encoding="utf8") as output:
+            with log_filepath.open("w", encoding="utf8") as output:
                 with contextlib.redirect_stderr(output):
                     with contextlib.redirect_stdout(output):
                         # intercept the stdout/stderr so we can do things such
@@ -180,28 +180,27 @@ def behave(
     return result
 
 
-def write_run_details(results, filepath):
-    """
-    writes a JSON file with run details to the results directory which can be
-    used to figure out any runtime details that would otherwise be lost and
-    difficult to figure out.
-    """
-    run_details_filepath = os.path.join(results, "run_details.json")
+def create_run(results, filepath):
+    results_path = Path(results)
+    run_json_filepath = results_path / "run_details.json"
 
-    if os.path.exists(run_details_filepath):
+    if run_json_filepath.exists():
         return
 
-    if CONFIG["CUCU_RECORD_ENV_VARS"]:
-        env_values = dict(os.environ)
-    else:
-        env_values = "To enable use the --record-env-vars flag"
+    env_values = (
+        dict(os.environ)
+        if CONFIG["CUCU_RECORD_ENV_VARS"]
+        else "To enable use the --record-env-vars flag"
+    )
 
     run_details = {
+        "cucu_run_id": CONFIG["CUCU_RUN_ID"],
         "filepath": filepath,
         "full_arguments": sys.argv,
         "env": env_values,
         "date": datetime.now().isoformat(),
     }
 
-    with open(run_details_filepath, "w", encoding="utf8") as output:
-        output.write(json.dumps(run_details, indent=2, sort_keys=True))
+    run_json_filepath.write_text(
+        json.dumps(run_details, indent=2, sort_keys=True), encoding="utf8"
+    )

cucu/config.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import re
 import socket
@@ -15,6 +16,7 @@ class Config(dict):
         self.resolving = False
         self.defined_variables = {}
         self.variable_lookups = {}
+        self.snapshots = []
 
     def define(self, name, description, default=None):
         """
@@ -255,19 +257,37 @@ class Config(dict):
 
         return string
 
-    def snapshot(self):
-        """
-        make a shallow copy of the current config values which can later be
-        restored using the `restore` method.
-        """
-        self.snapshot_data = self.copy()
+    def snapshot(self, name=None):
+        if name is None:
+            name = f"snapshot_{len(self.snapshots)}"
+
+        snapshot_data = {"name": name, "config": self.copy()}
+        self.snapshots.append(snapshot_data)
+
+        logging.debug(
+            f"CONFIG: snapshot taken '{name}' (stack depth: {len(self.snapshots)})"
+        )
+
+    def restore(self, with_pop=False):
+        if not self.snapshots:
+            return
+
+        if with_pop:
+            latest_snapshot = self.snapshots.pop()
+            action = "popped and restored"
+        else:
+            latest_snapshot = self.snapshots[-1]
+            action = "restored to"
 
-    def restore(self):
-        """
-        restore a previous `snapshot`
-        """
         self.clear()
-        self.update(**self.snapshot_data)
+        self.update(**latest_snapshot["config"])
+
+        logging.debug(
+            f"CONFIG: {action} snapshot '{latest_snapshot['name']}' (stack depth: {len(self.snapshots)})"
+        )
+
+    def list_snapshots(self):
+        return [snapshot["name"] for snapshot in self.snapshots]
 
     def register_custom_variable_handling(self, regex, lookup):
         """

cucu/environment.py

@@ -1,22 +1,22 @@
-import datetime
-import hashlib
 import json
-import os
 import sys
-import time
 import traceback
+from datetime import datetime
 from functools import partial
+from pathlib import Path
+
+import yaml
 
 from cucu import config, init_scenario_hook_variables, logger
 from cucu.config import CONFIG
 from cucu.page_checks import init_page_checks
-from cucu.utils import ellipsize_filename, take_screenshot
-
-CONFIG.define(
-    "FEATURE_RESULTS_DIR",
-    "the results directory for the currently executing feature",
-    default=None,
+from cucu.utils import (
+    TeeStream,
+    ellipsize_filename,
+    generate_short_id,
+    take_screenshot,
 )
+
 CONFIG.define(
     "SCENARIO_RESULTS_DIR",
     "the results directory for the currently executing scenario",
@@ -44,8 +44,12 @@ def check_browser_initialized(ctx):
 
 def before_all(ctx):
     CONFIG["__CUCU_CTX"] = ctx
-    CONFIG.snapshot()
     ctx.check_browser_initialized = partial(check_browser_initialized, ctx)
+    ctx.worker_custom_data = {}
+
+    CONFIG["WORKER_RUN_ID"] = generate_short_id()
+    CONFIG.snapshot("before_all")
+
     for hook in CONFIG["__CUCU_BEFORE_ALL_HOOKS"]:
         hook(ctx)
 
@@ -55,14 +59,16 @@ def after_all(ctx):
     for hook in CONFIG["__CUCU_AFTER_ALL_HOOKS"]:
         hook(ctx)
 
+    CONFIG.restore(with_pop=True)
+
 
 def before_feature(ctx, feature):
+    feature.feature_run_id = generate_short_id()
+    feature.custom_data = {}
+
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
-        results_dir = config.CONFIG["CUCU_RESULTS_DIR"]
-        ctx.feature_dir = os.path.join(
-            results_dir, ellipsize_filename(feature.name)
-        )
-        CONFIG["FEATURE_RESULTS_DIR"] = ctx.feature_dir
+        results_dir = Path(config.CONFIG["CUCU_RESULTS_DIR"])
+        ctx.feature_dir = results_dir / ellipsize_filename(feature.name)
 
 
 def after_feature(ctx, feature):
@@ -81,50 +87,54 @@ def before_scenario(ctx, scenario):
 
     init_scenario_hook_variables()
 
+    scenario.custom_data = {}
     ctx.scenario = scenario
     ctx.step_index = 0
+    ctx.scenario_index = ctx.feature.scenarios.index(scenario) + 1
     ctx.browsers = []
     ctx.browser = None
+    ctx.section_step_stack = []
 
     # reset the step timer dictionary
     ctx.step_timers = {}
+    scenario.start_at = datetime.now().isoformat()[:-3]
 
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
-        ctx.scenario_dir = os.path.join(
-            ctx.feature_dir, ellipsize_filename(scenario.name)
-        )
+        ctx.scenario_dir = ctx.feature_dir / ellipsize_filename(scenario.name)
         CONFIG["SCENARIO_RESULTS_DIR"] = ctx.scenario_dir
-        os.makedirs(ctx.scenario_dir, exist_ok=True)
+        ctx.scenario_dir.mkdir(parents=True, exist_ok=True)
 
-        ctx.scenario_downloads_dir = os.path.join(
-            ctx.scenario_dir, "downloads"
-        )
+        ctx.scenario_downloads_dir = ctx.scenario_dir / "downloads"
         CONFIG["SCENARIO_DOWNLOADS_DIR"] = ctx.scenario_downloads_dir
-        os.makedirs(ctx.scenario_downloads_dir, exist_ok=True)
+        ctx.scenario_downloads_dir.mkdir(parents=True, exist_ok=True)
 
-        ctx.scenario_logs_dir = os.path.join(ctx.scenario_dir, "logs")
+        ctx.scenario_logs_dir = ctx.scenario_dir / "logs"
         CONFIG["SCENARIO_LOGS_DIR"] = ctx.scenario_logs_dir
-        os.makedirs(ctx.scenario_logs_dir, exist_ok=True)
+        ctx.scenario_logs_dir.mkdir(parents=True, exist_ok=True)
 
-        cucu_debug_filepath = os.path.join(
-            ctx.scenario_logs_dir, "cucu.debug.console.log"
-        )
+        cucu_debug_log_path = ctx.scenario_logs_dir / "cucu.debug.console.log"
         ctx.scenario_debug_log_file = open(
-            cucu_debug_filepath, "w", encoding=sys.stdout.encoding
+            cucu_debug_log_path, "w", encoding=sys.stdout.encoding
         )
+        ctx.scenario_debug_log_tee = TeeStream(ctx.scenario_debug_log_file)
 
         # redirect stdout, stderr and setup a logger at debug level to fill
         # the scenario cucu.debug.log file which makes it possible to have
         # debug logging for every single scenario run without polluting the
         # console logs at runtime.
-        sys.stdout.set_other_stream(ctx.scenario_debug_log_file)
-        sys.stderr.set_other_stream(ctx.scenario_debug_log_file)
-        logger.init_debug_logger(ctx.scenario_debug_log_file)
+        sys.stdout.set_other_stream(ctx.scenario_debug_log_tee)
+        sys.stderr.set_other_stream(ctx.scenario_debug_log_tee)
+        logger.init_debug_logger(ctx.scenario_debug_log_tee)
+
+        # capture browser logs using TeeStream since each call clears the log
+        ctx.browser_log_file = open(
+            ctx.scenario_logs_dir / "browser_console.log.txt",
+            "w",
+            encoding="utf-8",
+        )
+        ctx.browser_log_tee = TeeStream(ctx.browser_log_file)
 
-    # internal cucu config variables
-    CONFIG["SCENARIO_RUN_ID"] = hashlib.sha256(
-        str(time.perf_counter()).encode("utf-8")
-    ).hexdigest()[:7]
+    CONFIG["SCENARIO_RUN_ID"] = scenario.scenario_run_id = generate_short_id()
 
     # run before all scenario hooks
     for hook in CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"]:
@@ -179,14 +189,18 @@ def after_scenario(ctx, scenario):
         if len(ctx.browsers) != 0:
             logger.debug("quitting browser between sessions")
 
-        run_after_scenario_hook(ctx, scenario, download_browser_logs)
+        run_after_scenario_hook(ctx, scenario, download_browser_log)
 
-    cucu_config_filepath = os.path.join(
-        ctx.scenario_logs_dir, "cucu.config.yaml.txt"
-    )
-    with open(cucu_config_filepath, "w") as config_file:
+    cucu_config_path = ctx.scenario_logs_dir / "cucu.config.yaml.txt"
+    with open(cucu_config_path, "w") as config_file:
         config_file.write(CONFIG.to_yaml_without_secrets())
 
+    scenario.cucu_config_json = json.dumps(
+        yaml.safe_load(CONFIG.to_yaml_without_secrets())
+    )
+
+    scenario.end_at = datetime.now().isoformat()[:-3]
+
 
 def download_mht_data(ctx):
     if not ctx.browsers:
@@ -198,45 +212,42 @@ def download_mht_data(ctx):
             mht_filename = (
                 f"browser{index if len(ctx.browsers) > 1 else ''}_snapshot.mht"
             )
-            mht_pathname = os.path.join(
-                CONFIG["SCENARIO_LOGS_DIR"],
-                mht_filename,
-            )
+            mht_pathname = CONFIG["SCENARIO_LOGS_DIR"] / mht_filename
             logger.debug(f"Saving MHT webpage snapshot: {mht_filename}")
             browser.download_mht(mht_pathname)
 
 
-def download_browser_logs(ctx):
+def download_browser_log(ctx):
     # close the browser unless someone has set the keep browser alive
     # environment variable which allows tests to reuse the same browser
     # session
 
     for browser in ctx.browsers:
-        # save the browser logs to the current scenarios results directory
-        browser_log_filepath = os.path.join(
-            ctx.scenario_logs_dir, "browser_console.log.txt"
-        )
-
-        os.makedirs(os.path.dirname(browser_log_filepath), exist_ok=True)
-        with open(browser_log_filepath, "w") as output:
-            for log in browser.get_log():
-                output.write(f"{json.dumps(log)}\n")
-
         browser.quit()
 
+    ctx.browser_log_file.close()
+
     ctx.browsers = []
 
 
 def before_step(ctx, step):
-    # trims the last 3 digits of the microseconds
-    step.start_timestamp = datetime.datetime.now().isoformat()[:-3]
+    step.step_run_id = generate_short_id()
+    step.start_at = datetime.now().isoformat()[:-3]
 
     sys.stdout.captured()
     sys.stderr.captured()
 
+    # Reset the debug log buffer for this step
+    if hasattr(ctx, "scenario_debug_log_tee"):
+        ctx.scenario_debug_log_tee.clear()
+
     ctx.current_step = step
     ctx.current_step.has_substeps = False
-    ctx.start_time = time.monotonic()
+    ctx.section_level = None
+    step.seq = ctx.step_index + 1
+    step.parent_seq = (
+        ctx.section_step_stack[-1].seq if ctx.section_step_stack else 0
+    )
 
     CONFIG["__STEP_SCREENSHOT_COUNT"] = 0
 
@@ -249,8 +260,18 @@ def after_step(ctx, step):
     step.stdout = sys.stdout.captured()
     step.stderr = sys.stderr.captured()
 
-    ctx.end_time = time.monotonic()
-    ctx.previous_step_duration = ctx.end_time - ctx.start_time
+    # Capture debug output from the TeeStream for this step
+    if hasattr(ctx, "scenario_debug_log_tee"):
+        step.debug_output = ctx.scenario_debug_log_tee.getvalue()
+    else:
+        step.debug_output = ""
+
+    step.end_at = datetime.now().isoformat()[:-3]
+
+    # calculate duration from ISO timestamps
+    start_at = datetime.fromisoformat(step.start_at)
+    end_at = datetime.fromisoformat(step.end_at)
+    ctx.previous_step_duration = (end_at - start_at).total_seconds()
 
     # when set this means we're running in parallel mode using --workers and
     # we want to see progress reported using simply dots
@@ -296,3 +317,26 @@ def after_step(ctx, step):
     # run after all step hooks
     for hook in CONFIG["__CUCU_AFTER_STEP_HOOKS"]:
         hook(ctx)
+
+    # Capture browser logs and info for this step
+    step.browser_logs = ""
+
+    browser_info = {"has_browser": False}
+    if ctx.browser:
+        browser_logs = []
+        for log in ctx.browser.get_log():
+            log_entry = json.dumps(log)
+            browser_logs.append(log_entry)
+            ctx.browser_log_tee.write(f"{log_entry}\n")
+        step.browser_logs = "\n".join(browser_logs)
+
+        tab_info = ctx.browser.get_tab_info()
+        all_tabs = ctx.browser.get_all_tabs_info()
+
+        browser_info = {
+            "current_tab_index": tab_info["index"],
+            "all_tabs": all_tabs,
+            "browser_type": ctx.browser.driver.name,
+        }
+
+    step.browser_info = json.dumps(browser_info)

cucu/formatter/cucu.py

@@ -185,7 +185,7 @@ class CucuFormatter(Formatter):
             max_line_length = self.calculate_max_line_length()
             status_text = ""
             if self.show_timings:
-                start = step.start_timestamp
+                start = step.start_at
                 duration = f"{step.duration:.3f}"
                 status_text += f" # started at {start} took {duration}s"
 

cucu/formatter/json.py

@@ -157,7 +157,7 @@ class CucuJSONFormatter(Formatter):
 
         timestamp = None
         if step.status.name in ["passed", "failed"]:
-            timestamp = step.start_timestamp
+            timestamp = step.start_at
 
             step_variables = CONFIG.expand(step.name)
 

cucu/steps/section_steps.py

@@ -1,3 +1,5 @@
+import logging
+
 from behave import use_step_matcher
 
 from cucu import step
@@ -6,7 +8,7 @@ use_step_matcher("re")  # use regex to match section heading patterns
 
 
 @step("(#{1,4})\\s*(.*)")
-def section_step(ctx, heading_level, section_text):
+def section_step(ctx, section_level, section_text):
     """
     A section heading step that organizes scenarios into logical sections.
 
@@ -19,7 +21,24 @@ def section_step(ctx, heading_level, section_text):
     The number of # characters determines the heading level (1-4).
     This step is a no-op but provides structure in the HTML report.
     """
-    pass
+    step = ctx.current_step
+    step.section_level = len(section_level)
+    step.parent_seq = 0
+
+    while len(ctx.section_step_stack):
+        latest_section = ctx.section_step_stack[-1]
+        if latest_section.section_level < step.section_level:
+            step.parent_seq = latest_section.seq
+            break
+        ctx.section_step_stack.pop()
+        logging.debug(
+            f"Section: exited '{latest_section.name}' (level {latest_section.section_level})"
+        )
+
+    ctx.section_step_stack.append(ctx.current_step)
+    logging.debug(
+        f"Section: entering '{step.name}' (level {step.section_level})"
+    )
 
 
 use_step_matcher("parse")  # set this back to cucu's default matcher parser

cucu/utils.py

@@ -3,10 +3,12 @@ various cucu utilities can be placed here and then exposed publicly through
 the src/cucu/__init__.py
 """
 
+import hashlib
 import logging
 import os
 import pkgutil
 import shutil
+import time
 
 import humanize
 from selenium.webdriver.common.by import By
@@ -41,6 +43,16 @@ class StopRetryException(Exception):
     pass
 
 
+def generate_short_id():
+    """
+    Generate a short 7-character ID based on current performance counter.
+    Used for both cucu_run_id and scenario_run_id.
+    """
+    return hashlib.sha256(
+        str(time.perf_counter()).encode("utf-8")
+    ).hexdigest()[:7]
+
+
 def format_gherkin_table(table, headings=[], prefix=""):
     formatted = tabulate(table, headings, tablefmt=GHERKIN_TABLEFORMAT)
     if prefix == "":
@@ -76,7 +88,7 @@ def run_steps(ctx, steps_text):
     steps = ctx.feature.parser.parse_steps(steps_text)
 
     current_step = ctx.current_step
-    current_step_start_time = ctx.start_time
+    current_step_start_at = current_step.start_at
 
     # XXX: I want to get back to this and find a slightly better way to handle
     #      these substeps without mucking around with so much state in behave
@@ -101,7 +113,7 @@ def run_steps(ctx, steps_text):
             ctx.text = original_text
     finally:
         ctx.current_step = current_step
-        ctx.start_time = current_step_start_time
+        ctx.current_step.start_at = current_step_start_at
 
     return True
 
@@ -222,6 +234,10 @@ def take_saw_element_screenshot(ctx, thing, name, index, element=None):
 
 
 def take_screenshot(ctx, step_name, label="", element=None):
+    step = ctx.current_step
+    if not hasattr(step, "screenshots"):
+        step.screenshots = []
+
     screenshot_dir = os.path.join(
         ctx.scenario_dir, get_step_image_dir(ctx.step_index, step_name)
     )
@@ -268,6 +284,20 @@ def take_screenshot(ctx, step_name, label="", element=None):
         """
         ctx.browser.execute(clear_highlight, element)
 
+    screenshot = {
+        "step_name": step_name,
+        "label": label,
+        "element": element,
+        "location": f"({element.location['x']},{element.location['y']})"
+        if element
+        else "",
+        "size": f"({element.size['width']},{element.size['height']})"
+        if element
+        else "",
+        "filepath": filepath,
+    }
+    step.screenshots.append(screenshot)
+
     if CONFIG["CUCU_MONITOR_PNG"]:
         shutil.copyfile(filepath, CONFIG["CUCU_MONITOR_PNG"])
 
@@ -297,3 +327,31 @@ def find_n_click_input_parent_label(ctx, input_element):
 def is_element_size_zero(element):
     size = element.size
     return size["width"] == 0 and size["height"] == 0
+
+
+class TeeStream:
+    """
+    A stream that writes to both a file stream and captures content in an internal buffer.
+    Provides file-like accessors to read the captured content.
+    """
+
+    def __init__(self, file_stream):
+        self.file_stream = file_stream
+        self.string_buffer = []
+
+    def write(self, data):
+        self.file_stream.write(data)
+        self.string_buffer.append(data)
+
+    def flush(self):
+        self.file_stream.flush()
+
+    def getvalue(self):
+        return "".join(self.string_buffer)
+
+    def read(self):
+        return self.getvalue()
+
+    def clear(self):
+        """Clear the internal buffer."""
+        self.string_buffer = []

{cucu-1.2.4.dist-info → cucu-1.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cucu
-Version: 1.2.4
+Version: 1.2.5
 Summary: Easy BDD web testing
 Keywords: cucumber,selenium,behave
 Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya, Kevin Garton, Joy Liao

{cucu-1.2.4.dist-info → cucu-1.2.5.dist-info}/RECORD

@@ -7,19 +7,19 @@ cucu/browser/frames.py,sha256=216ee4cd1267e4f91b31aa2f21e94078258ef93fb6b0e4f0a9
 cucu/browser/selenium.py,sha256=7940b60d9921508662ef4b154da344ff40216a719371ecb1fe908b213ecf37aa,13299
 cucu/browser/selenium_tweaks.py,sha256=a1422159584165b73daac99050932922bf6e5162b1b60641727c92594e98b6d9,879
 cucu/cli/__init__.py,sha256=b975f9c951b59289c9fc835d96b71f320f93b7fe7f712c76f4477c47cbfdd3c0,62
-cucu/cli/core.py,sha256=b00bd1222ff671de0e42228a21293b59e6f9faee4a58ad4335b6b2a9abfcb696,26915
-cucu/cli/run.py,sha256=b9939fd5ce730174f44e1690beb6f99205c6c25f34940b476939b9743c289678,5909
+cucu/cli/core.py,sha256=23014432183140fe2f1adfe644205151f8d367a0b6e2dd0ee18800c9aad9d8a7,27151
+cucu/cli/run.py,sha256=9e30943b42f71c2f16113ffb913ce07d36a721938420b30c28cd9d08ea7dae42,5713
 cucu/cli/steps.py,sha256=960e62b551ff0bed3fdd17a5597bfd5f6a90507820771bb12c21b01f99756dfe,4210
 cucu/cli/thread_dumper.py,sha256=6775e7612c62771ea9aa3950ef3bbe4ca3086195a4e33f5ce582dd3e471e9a25,1593
-cucu/config.py,sha256=b0096acc17efe448b00b89ba04a70c264224906228cf67867760be2643f27f24,14305
+cucu/config.py,sha256=e4013a1ab92ace3361cf3ac1f9e66b20d81eced57b0821ae49d589fb91ad5a19,14939
 cucu/edgedriver_autoinstaller/README.md,sha256=b43900588aa045d0a3b7ea17d6762a8a4202fc57e2384336fa97394b955b44ba,84
 cucu/edgedriver_autoinstaller/__init__.py,sha256=7e8eb12493ef71ce57be78bc7a95dfc43a0fc491f9fdbe959368c3f494f07d1b,969
 cucu/edgedriver_autoinstaller/utils.py,sha256=891293c30efb086693027b6dfd00efc6528fc69314e28b71f7939e0fdee485c3,6802
-cucu/environment.py,sha256=353aaf8dd747aefe133e1f4536aab9c67c2adb5a297f91eb29925bdce8b6720e,9950
+cucu/environment.py,sha256=1ec72f24abb3ae9ff214a3b6a44f00b0e42e0258399b13d8f21d5d1ab39a8d0f,11426
 cucu/external/jquery/jquery-3.5.1.min.js,sha256=f7f6a5894f1d19ddad6fa392b2ece2c5e578cbf7da4ea805b6885eb6985b6e3d,89476
 cucu/formatter/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-cucu/formatter/cucu.py,sha256=2424ab0e3b9933b8aef37b35fa436e3f6bac0e43b1fd4e94d2fd797959a6cab2,9298
-cucu/formatter/json.py,sha256=f17d67de3040973bfcac2fd2f89a7e5377233e7bc6cd733a3018c0b9d82b00f5,10596
+cucu/formatter/cucu.py,sha256=8c78ba5bd4934508c3cb48f53ff1cb2e50533ec4ba12f532bea7948ed5acdef3,9291
+cucu/formatter/json.py,sha256=7c9d5d6411b0603e0e9214050c4e3d311286373b2b843cd062af9d51fb1887de,10589
 cucu/formatter/junit.py,sha256=689f5d18b6da98c1fec148bf9ac17aebffbf73f614ab4efef3fc023448d48eee,10129
 cucu/fuzzy/__init__.py,sha256=71ee0946668117aa1a6fa53df506e9b7b0eb0f77a5847df6ffff8d0fa7f0e717,104
 cucu/fuzzy/core.py,sha256=b6640a5ff362fb6a21a31cdcb51520db1ef331e116f0c949266a54dcf7d39af4,3153
@@ -77,7 +77,7 @@ cucu/steps/link_steps.py,sha256=3102f1ca309b885d9d3ac9a3e88aca2a545885aa898f10d4
 cucu/steps/menuitem_steps.py,sha256=f4995a3cee814a65b618f9a4e378311b2e52d37ac4b44c78284d2e0850648e4d,1133
 cucu/steps/platform_steps.py,sha256=1bb1ed04c85d46ee7cfb6fcb7570b9ae424cf45d62bc676545af41cd388769a6,754
 cucu/steps/radio_steps.py,sha256=17281434f084057ce6cc63072fc0d836d2def6ae2a8dec884e244b1fee4d6da8,5931
-cucu/steps/section_steps.py,sha256=5de4af2e47fba3f548a15830cb1037ebef47ffd5c852200027a11b22a7ac8481,645
+cucu/steps/section_steps.py,sha256=041b11b494ee6ff2f582b2a78110a3eedf9ff12e2284e421b7af130b33c7671c,1283
 cucu/steps/step_utils.py,sha256=0a17743506cc9df004266424a1541131b5516c29c9201bd5787ec2997ac2326d,1417
 cucu/steps/tab_steps.py,sha256=4d5572b648a1bc9d86610f5bc00b35095cdbfadc3352ad7540e36511b77ab8ed,1818
 cucu/steps/table_steps.py,sha256=e5b053d8772e2f2fb027cbd4b1c86a9071040fefc63cf270a9da4b1654b87bd7,13744
@@ -85,8 +85,8 @@ cucu/steps/tables.js,sha256=3acd9aec5a3e720d375d5962ed44af72705569de0dee2757afe1
 cucu/steps/text_steps.py,sha256=263fc61e81de7a637055d50e76a71e840acda7b58cf96323963038c34a4b5eec,2576
 cucu/steps/variable_steps.py,sha256=59272d1f7ff17318e28c63d8665c69f9fa02fd220000ab45fffb1a36d81925b9,2966
 cucu/steps/webserver_steps.py,sha256=c169294af71231d8ac90f921e1caa57a95b1d6792f1294d4dad4574263c36f2a,1410
-cucu/utils.py,sha256=60c04926b4065bb4da17e3a0d5cb4001af1150d48dcd0f602570f9930b2858c0,9464
-cucu-1.2.4.dist-info/WHEEL,sha256=ab6157bc637547491fb4567cd7ddf26b04d63382916ca16c29a5c8e94c9c9ef7,79
-cucu-1.2.4.dist-info/entry_points.txt,sha256=d7559122140cecbb949d0835940a1942836fbc1bd834dd666838104b8763c09a,40
-cucu-1.2.4.dist-info/METADATA,sha256=848ee398aae88549ac768f9a21e9d05b52eb6f8e6a60dcffaaa28f81b1b5cb0e,16675
-cucu-1.2.4.dist-info/RECORD,,
+cucu/utils.py,sha256=a79b12b89cc67409bda959310a384cacbe13f87e54241720f88bf303b7fcb9bb,10939
+cucu-1.2.5.dist-info/WHEEL,sha256=03f80d698bb4300c27bcafc3987ea73ef427fcb365e59e808e50d041a7f87b89,78
+cucu-1.2.5.dist-info/entry_points.txt,sha256=d7559122140cecbb949d0835940a1942836fbc1bd834dd666838104b8763c09a,40
+cucu-1.2.5.dist-info/METADATA,sha256=2d068e4f9b75fafa2cdae5f25a4bb612e24fce621847dfeef55eac3bc73c3924,16675
+cucu-1.2.5.dist-info/RECORD,,

{cucu-1.2.4.dist-info → cucu-1.2.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.7.22
+Generator: uv 0.8.2
 Root-Is-Purelib: true
 Tag: py3-none-any