pytestflow 0.2.0__py3-none-any.whl

pytestflow/steps/action_step.py

@@ -0,0 +1,94 @@
+# pytestflow/steps/action_step.py
+
+from prefect.artifacts import create_markdown_artifact
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowDone, PyTestflowError
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context
+from datetime import datetime
+import re
+
+
+class ActionStep(StepWrapper):
+    def __init__(self, fn, *, name=None, store_as=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)
+        self.store_as = store_as
+        self.step_type = "action"
+
+
+    def _run(self, *args, **kwargs):
+        from pytestflow.core.context import ptf_context
+
+        try:
+            # Execute user code (inside the Prefect task created by StepWrapper)
+            result = super()._run(*args, **kwargs)
+
+            # Optionally store the result in the context
+            if self.store_as:
+                ptf_context.locals[self.store_as] = result
+
+            result_data = {
+                "step_status": "done",
+                "output": result,
+                "step_type": self.step_type,
+                "pytestflow_timestamp": datetime.utcnow().isoformat(),
+                "store_as": self.store_as,
+            }
+
+            result_data.update(self.get_meta_info())
+            result_data.update(get_metadata_from_prefect_context())
+
+            # Send End data to GUI
+            get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+            # Prefect UI artifact (best-effort)
+            try:
+                safe_step_name = re.sub(r"[^a-z0-9\\-]", "-", self.name.lower())
+                artifact_md = (
+                    f"### Step: `{self.name}`\n"
+                    f"- **Output:** `{result}`\n"
+                    f"- **Stored as:** `{self.store_as or 'None'}`\n"
+                    f"- **Status:** ✅ DONE"
+                )
+                create_markdown_artifact(
+                    key=f"result-{safe_step_name}",
+                    markdown=artifact_md,
+                    description=f"Action result for `{self.name}`",
+                )
+            except Exception:
+                pass
+
+            return PyTestflowDone(
+                ptf_result=result_data,
+                result=result,
+                message="Action step completed",
+            )
+
+        except Exception as e:
+            result_data = {
+                "step_status": "error",
+                "error": str(e),
+                "step_type": "action",
+                "pytestflow_timestamp": datetime.utcnow().isoformat(),
+                "store_as": self.store_as,
+            }
+
+            result_data.update(self.get_meta_info())
+            # optional: include Prefect metadata even on error (useful)
+            result_data.update(get_metadata_from_prefect_context())
+
+            return PyTestflowError(
+                ptf_result=result_data,
+                message=f"Action step `{self.name}` failed",
+                result=None,
+            )
+
+
+def action_step(*, name=None, store_as=None, autowire=True, **task_kwargs):
+    """
+    Decorator factory for action steps.
+    """
+    def decorator(fn):
+        # IMPORTANT: already task-wrapped by StepWrapper
+        return ActionStep(fn, name=name, store_as=store_as, autowire=autowire, **task_kwargs)
+    return decorator

pytestflow/steps/common.py

@@ -0,0 +1,51 @@
+from prefect.context import get_run_context
+import warnings
+
+def safe_getattr(obj, attr, default=None):
+    try:
+        return getattr(obj, attr, default)
+    except Exception:
+        return default
+
+
+def get_metadata_from_prefect_context():
+    metadata = {
+        "flow_run_id": None,
+        "flow_name": None,
+        "task_run_id": None,
+        "task_name": None,
+    }
+
+    # 1) Get task metadata from run context (works well inside tasks)
+    try:
+        run_ctx = get_run_context()
+        task_run = safe_getattr(run_ctx, "task_run", None)
+
+        metadata["task_run_id"] = safe_getattr(task_run, "id")
+        metadata["task_name"]   = safe_getattr(task_run, "name")
+    except RuntimeError:
+        warnings.warn(
+            "Prefect context is unavailable. Metadata enrichment is skipped.",
+            RuntimeWarning,
+        )
+        return metadata
+
+    # 2) Get flow metadata from Prefect runtime (most reliable)
+    try:
+        from prefect.runtime import flow_run
+        metadata["flow_run_id"] = safe_getattr(flow_run, "id")
+        metadata["flow_name"]   = safe_getattr(flow_run, "name")
+    except Exception:
+        # 3) Fallback: try flow_run from context if present
+        try:
+            run_ctx = get_run_context()
+            flow_run_obj = safe_getattr(run_ctx, "flow_run", None)
+            metadata["flow_run_id"] = metadata["flow_run_id"] or safe_getattr(flow_run_obj, "id")
+            metadata["flow_name"]   = metadata["flow_name"] or safe_getattr(flow_run_obj, "name")
+        except Exception:
+            pass
+
+    return metadata
+
+def get_runtime_value(value):
+    return value() if callable(value) else value

pytestflow/steps/df_numeric_limits.py

@@ -0,0 +1,151 @@
+from prefect.artifacts import create_markdown_artifact
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowPassed, PyTestflowFailed
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context, get_runtime_value
+from typing import Callable
+import pandas as pd
+import re
+
+
+class DFNumericLimitsStep(StepWrapper):
+    def __init__(self, fn, *, limits_df: pd.DataFrame, name=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)
+        self.limits_df = limits_df
+        self.step_type = "df_numeric_limits"
+
+
+    def _run(self, *args, **kwargs):
+        values = super()._run(*args, **kwargs)
+
+        limits_df = get_runtime_value(self.limits_df)
+
+        if not isinstance(values, (dict, pd.Series)):
+            raise TypeError("Return value must be dict or pd.Series")
+
+        results = []
+        overall_status = "passed"
+
+        for _, row in limits_df.iterrows():
+            varname = row["name"]
+
+            try:
+                val = values[varname]
+                limit = row["limit"]
+                mode = row["mode"]
+
+                if mode == "ge":
+                    status = "passed" if val >= limit else "failed"
+
+                elif mode == "le":
+                    status = "passed" if val <= limit else "failed"
+
+                elif mode == "between":
+                    low, high = limit
+                    status = "passed" if low <= val <= high else "failed"
+
+                elif mode == "outside":
+                    low, high = limit
+                    status = "passed" if val < low or val > high else "failed"
+
+                else:
+                    raise ValueError(f"Unsupported mode: {mode}")
+
+                if status != "passed":
+                    overall_status = "failed"
+
+                result = {
+                    "name": varname,
+                    "value": val,
+                    "limit": limit,
+                    "mode": mode,
+                    "step_status": status,
+                }
+
+            except Exception as e:
+                result = {
+                    "name": varname,
+                    "step_status": "error",
+                    "error": str(e),
+                }
+                overall_status = "failed"
+
+            results.append(result)
+
+        result_data = {
+            "step_status": overall_status,
+            "output": values,
+            "per_variable": results,
+            "step_type": self.step_type,
+        }
+
+        result_data.update(self.get_meta_info())
+        result_data.update(get_metadata_from_prefect_context())
+
+        # Send End data to GUI
+        get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+        # Prefect UI artifact (best-effort)
+        try:
+            safe_step_name = re.sub(r"[^a-z0-9\-]", "-", self.name.lower())
+
+            md_lines = [
+                f"### Step: `{self.name}`",
+                f"- **Status:** {'✅ PASSED' if overall_status == 'passed' else '❌ FAILED'}",
+                "",
+            ]
+
+            if overall_status == "failed":
+                failed_results = [r for r in results if r.get("step_status") != "passed"]
+
+                md_lines += [
+                    f"**{len(failed_results)}** variable(s) failed limits.",
+                    "",
+                    "| Variable | Value | Limit | Mode | Status |",
+                    "|---|---|---|---|---|",
+                ]
+
+                for r in failed_results[:10]:
+                    md_lines.append(
+                        f"| {r.get('name')} | {r.get('value', 'NA')} | {r.get('limit', 'NA')} | "
+                        f"{r.get('mode', 'NA')} | {r.get('step_status', 'error')} |"
+                    )
+
+                if len(failed_results) > 10:
+                    md_lines.append(
+                        f"\n… and **{len(failed_results) - 10} more**. See full report for details."
+                    )
+
+            create_markdown_artifact(
+                key=f"result-{safe_step_name}",
+                markdown="\n".join(md_lines),
+                description=f"DataFrame numeric limits for `{self.name}`",
+            )
+
+        except Exception:
+            pass
+
+        return (
+            PyTestflowPassed(ptf_result=result_data)
+            if overall_status == "passed"
+            else PyTestflowFailed(
+                ptf_result=result_data,
+                message=f"{self.name} failed"
+            )
+        )
+
+
+def df_numeric_limits_step(*, limits_df: pd.DataFrame, name=None, autowire=True, **task_kwargs):
+    """
+    Decorator factory for DataFrame numeric limit steps.
+    """
+    def decorator(fn: Callable):
+        # IMPORTANT: already task-wrapped by StepWrapper
+        return DFNumericLimitsStep(
+            fn,
+            limits_df=limits_df,
+            name=name,
+            autowire=autowire,
+            **task_kwargs,
+        )
+    return decorator

pytestflow/steps/flow_control.py

@@ -0,0 +1,86 @@
+from datetime import datetime
+from typing import Callable
+
+from pytestflow.core.context import ptf_context
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowDone, PyTestflowError
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context, get_runtime_value
+
+
+class FlowControlStep(StepWrapper):
+    def __init__(self, fn, *, next_steps={0:"next", 1:"next"}, name=None, store_as=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)        
+        self.next_steps = next_steps
+        self.store_as = store_as
+        self.step_type = "flow_control"
+
+    def _run(self, *args, **kwargs):
+        try:
+            result = super()._run(*args, **kwargs)
+
+            next_steps_map = get_runtime_value(self.next_steps)
+            store_as = get_runtime_value(self.store_as)
+
+            if store_as:
+                ptf_context.locals[store_as] = result
+
+            actual_next_steps = next_steps_map.get(result, "next")
+            ptf_context.locals["_ptf_next_step"] = actual_next_steps
+
+            result_data = {
+                "step_status": "done",
+                "output": result,
+                "step_type": self.step_type,
+                "pytestflow_timestamp": datetime.utcnow().isoformat(),
+                "store_as": store_as,
+                "flow_control_next_steps": next_steps_map,
+                "selected_next_step": actual_next_steps,
+                "retry_n": ptf_context.locals.get("retry_n"),
+            }
+
+            result_data.update(self.get_meta_info())
+            result_data.update(get_metadata_from_prefect_context())
+
+            get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+            return PyTestflowDone(
+                ptf_result=result_data,
+                message="Flow control step completed",
+            )
+
+        except Exception as exc:
+            result_data = {
+                "step_status": "error",
+                "error": str(exc),
+                "step_type": self.step_type,
+                "pytestflow_timestamp": datetime.utcnow().isoformat(),
+                "store_as": get_runtime_value(self.store_as),
+                "retry_n": ptf_context.locals.get("retry_n"),
+            }
+
+            result_data.update(self.get_meta_info())
+            result_data.update(get_metadata_from_prefect_context())
+
+            return PyTestflowError(
+                ptf_result=result_data,
+                message=f"Flow control step `{self.name}` failed",
+            )
+
+
+def flow_control_step(*, next_steps={0:"next", 1:"next"}, name=None, store_as=None, autowire=True, **task_kwargs):
+    """
+    Decorator factory for control-only steps that steer sequence execution.
+    """
+
+    def decorator(fn: Callable):
+        return FlowControlStep(
+            fn,
+            name=name,
+            next_steps=next_steps,
+            store_as=store_as,
+            autowire=autowire,
+            **task_kwargs,
+        )
+
+    return decorator

pytestflow/steps/message_pop_up.py

@@ -0,0 +1,76 @@
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowDone
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context, get_runtime_value
+from typing import Callable
+from pytestflow.core.runtime_control import runtime_control
+
+
+class MessagePopUpStep(StepWrapper):
+    def __init__(self, fn, *, show_response_box=False, title="", msg="", buttons=[], name=None, store_as=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)
+        self.step_type = "message_pop_up"
+        self.show_response_box = show_response_box
+        self.title = title
+        self.msg = msg
+        self.buttons = buttons
+        self.store_as = store_as
+        
+    def _run(self, *args, **kwargs):
+        # Executes inside the Prefect task created by StepWrapper
+        value = super()._run(*args, **kwargs)
+
+        show_response_box = get_runtime_value(self.show_response_box)
+        title = get_runtime_value(self.title)
+        msg = get_runtime_value(self.msg)
+        buttons = get_runtime_value(self.buttons)
+        store_as = get_runtime_value(self.store_as)
+
+        popup_data = {
+            "isResponseBoxVisible": show_response_box,
+            "title": title,
+            "msg": msg,
+            "buttons": buttons,
+        }
+
+        user_response = runtime_control.show_popup(popup_data)
+
+        if store_as:
+            from pytestflow.core.context import ptf_context
+            ptf_context.locals[store_as] = user_response
+
+        result_data = {
+            "step_status": "done",
+            "step_type": self.step_type,
+            "user_response": user_response,
+            "show_response_box": show_response_box,
+            "title": title,
+            "msg": msg,
+            "buttons": buttons,
+            "store_as": store_as,
+        }
+
+        result_data.update(self.get_meta_info())
+        result_data.update(get_metadata_from_prefect_context())
+
+        # Send End data to GUI
+        get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+        return PyTestflowDone(ptf_result=result_data)
+def message_pop_up_step(*, show_response_box=False, title="TITLE_HERE", msg="MSG_HERE", buttons=["Ok"], name=None, store_as=None, autowire=True, **task_kwargs):
+    """
+    Decorator factory for message pop-up steps.
+    """
+    def decorator(fn: Callable):
+        # IMPORTANT: already task-wrapped by StepWrapper
+        return MessagePopUpStep(
+            fn, 
+            show_response_box=show_response_box,
+            title=title, 
+            msg=msg, 
+            buttons=buttons, 
+            name=name, 
+            store_as=store_as,
+            autowire=autowire,
+            **task_kwargs)
+    return decorator

pytestflow/steps/numeric_limit.py

@@ -0,0 +1,109 @@
+# numeric_limit_step.py
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowPassed, PyTestflowFailed
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context, get_runtime_value
+from typing import Callable
+import re
+from prefect.artifacts import create_markdown_artifact
+
+
+class NumericLimitStep(StepWrapper):
+    def __init__(self, fn, *, limit, mode, name=None, store_as=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)
+        self.limit = limit
+        self.mode = mode
+        self.store_as = store_as
+        self.step_type = "numeric_limit"
+
+
+    def _run(self, *args, **kwargs):
+        from pytestflow.core.context import ptf_context
+
+        value = super()._run(*args, **kwargs)
+
+        limit = get_runtime_value(self.limit)
+        mode = get_runtime_value(self.mode)
+        store_as = get_runtime_value(self.store_as)
+
+        if not isinstance(value, (int, float)):
+            raise TypeError("Return value must be numeric")
+
+        if mode == "ge":
+            passed = value >= limit
+
+        elif mode == "le":
+            passed = value <= limit
+
+        elif mode == "between":
+            assert isinstance(limit, (list, tuple)) and len(limit) == 2
+            passed = limit[0] <= value <= limit[1]
+
+        elif mode == "outside":
+            assert isinstance(limit, (list, tuple)) and len(limit) == 2
+            passed = value < limit[0] or value > limit[1]
+
+        else:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+        if store_as:
+            ptf_context.locals[store_as] = value
+
+        result_data = {
+            "measurement": value,
+            "limit": limit,
+            "mode": mode,
+            "store_as": store_as,
+            "step_status": "passed" if passed else "failed",
+            "output": value,
+            "step_type": self.step_type,
+        }
+
+        result_data.update(self.get_meta_info())
+        result_data.update(get_metadata_from_prefect_context())
+
+        # Send End data to GUI
+        get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+        try:
+            safe_step_name = re.sub(r"[^a-z0-9\-]", "-", self.name.lower())
+
+            artifact_md = (
+                f"### Step: `{self.name}`\n"
+                f"- **Measurement:** `{value}`\n"
+                f"- **Limit ({mode}):** `{limit}`\n"
+                f"- **Status:** {'✅ PASSED' if passed else '❌ FAILED'}"
+            )
+
+            create_markdown_artifact(
+                key=f"result-{safe_step_name}",
+                markdown=artifact_md,
+                description=f"Numeric limit check for `{self.name}`",
+            )
+
+        except RuntimeError:
+            pass
+
+        return (
+            PyTestflowPassed(ptf_result=result_data)
+            if passed
+            else PyTestflowFailed(
+                ptf_result=result_data,
+                message=f"{self.name} failed"
+            )
+        )
+
+
+def numeric_limit_step(*, limit, mode="ge", name=None, store_as=None, autowire=True, **task_kwargs):
+    def decorator(fn: Callable):
+        # IMPORTANT: return the step instance (already task-wrapped by StepWrapper)
+        return NumericLimitStep(
+            fn,
+            limit=limit,
+            mode=mode,
+            name=name,
+            store_as=store_as,
+            autowire=autowire,
+            **task_kwargs,
+        )
+    return decorator

pytestflow/steps/pass_fail.py

@@ -0,0 +1,49 @@
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.pytestflow_states import PyTestflowPassed, PyTestflowFailed
+from pytestflow.core.utils import get_data_for_gui
+from pytestflow.steps.common import get_metadata_from_prefect_context
+from typing import Callable
+
+
+class PassFailStep(StepWrapper):
+    def __init__(self, fn, *, name=None, autowire=True, **task_kwargs):
+        super().__init__(fn, name=name, autowire=autowire, **task_kwargs)
+        self.step_type = "pass_fail"
+
+
+    def _run(self, *args, **kwargs):
+        # Executes inside the Prefect task created by StepWrapper
+        value = super()._run(*args, **kwargs)
+
+        passed = bool(value)
+
+        result_data = {
+            "step_status": "passed" if passed else "failed",
+            "output": value,
+            "step_type": self.step_type,
+        }
+
+        result_data.update(self.get_meta_info())
+        result_data.update(get_metadata_from_prefect_context())
+
+        # Send End data to GUI
+        get_data_for_gui(self, result_data.get("end_time"), result_data)
+
+        return (
+            PyTestflowPassed(ptf_result=result_data)
+            if passed
+            else PyTestflowFailed(
+                ptf_result=result_data,
+                message=f"{self.name} failed"
+            )
+        )
+
+
+def pass_fail_step(*, name=None, autowire=True, **task_kwargs):
+    """
+    Decorator factory for pass/fail steps.
+    """
+    def decorator(fn: Callable):
+        # IMPORTANT: already task-wrapped by StepWrapper
+        return PassFailStep(fn, name=name, autowire=autowire, **task_kwargs)
+    return decorator