PyClickerRPA 0.1.0__py3-none-any.whl

autoclicker/gui/monitor.py

@@ -0,0 +1,84 @@
+"""Trigger / monitor mode.
+
+Polls the target window (or full screen) on an interval for a condition (an
+image appearing, or a pixel matching a color) and fires ``triggered`` on the
+rising edge (false -> true), so a task runs once per appearance rather than
+every tick.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, QTimer, Signal
+
+
+def _parse_hex(name: str):
+    s = (name or "").strip().lstrip("#")
+    if len(s) == 3:
+        s = "".join(c * 2 for c in s)
+    if len(s) != 6:
+        return None
+    try:
+        return int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)
+    except ValueError:
+        return None
+
+
+class MonitorController(QObject):
+    triggered = Signal()
+    status = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self._tick)
+        self._cond: dict | None = None
+        self._hwnd = None
+        self._prev = False
+
+    def start(self, hwnd, cond: dict):
+        self._hwnd = hwnd
+        self._cond = cond
+        self._prev = False
+        self._timer.setInterval(int(cond.get("interval_ms", 1000)))
+        self._timer.start()
+        self.status.emit("监视中…")
+
+    def stop(self):
+        self._timer.stop()
+        self.status.emit("已停止监视")
+
+    def is_active(self) -> bool:
+        return self._timer.isActive()
+
+    def _tick(self):
+        met = False
+        try:
+            met = self._check()
+        except Exception as e:
+            self.status.emit(f"监视出错: {e}")
+        if met and not self._prev:
+            self.triggered.emit()
+        self._prev = met
+
+    def _check(self) -> bool:
+        import cv2
+        from autoclicker import capture, matcher
+        screen = capture.capture_window(self._hwnd) if self._hwnd else capture.capture_screen()
+        if screen is None or screen.size == 0:
+            return False
+        c = self._cond or {}
+        if c.get("type") == "image":
+            templ = cv2.imread(c["image"]) if c.get("image") else None
+            if templ is None:
+                return False
+            return bool(matcher.find_image(screen, templ, c.get("threshold", 0.8)))
+        if c.get("type") == "color":
+            x, y = int(c.get("x", 0)), int(c.get("y", 0))
+            if x >= screen.shape[1] or y >= screen.shape[0]:
+                return False
+            rgb = _parse_hex(c.get("color", ""))
+            if rgb is None:
+                return False
+            b, g, r = (int(v) for v in screen[y, x][:3])
+            tol = int(c.get("tolerance", 30))
+            return abs(r - rgb[0]) <= tol and abs(g - rgb[1]) <= tol and abs(b - rgb[2]) <= tol
+        return False

autoclicker/gui/preview_label.py

@@ -0,0 +1,176 @@
+"""Screenshot preview with interactive picking — port of previewlabel.cpp.
+
+Shows a BGR ndarray scaled-to-fit, maps mouse coordinates back to image space,
+and supports four pick modes used by the toolbar:
+  - point  : single click  -> pointPicked(QPoint)
+  - region : drag rectangle -> regionSelected(QRect)   (ROI / template crop)
+  - twopts : two clicks     -> twoPointsPicked(start, end)  (drag/swipe design)
+  - color  : single click   -> colorPicked(QPoint, QColor)
+"""
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+import numpy as np
+from PySide6.QtCore import QPoint, QRect, QSize, Qt, Signal
+from PySide6.QtGui import QColor, QImage, QPixmap
+from PySide6.QtWidgets import QLabel, QRubberBand
+
+
+def ndarray_to_qimage(bgr: np.ndarray) -> QImage:
+    """Convert an (H, W, 3) BGR ndarray to a QImage (copied, RGB888)."""
+    if bgr is None or bgr.size == 0:
+        return QImage()
+    rgb = np.ascontiguousarray(bgr[:, :, ::-1])  # BGR -> RGB
+    h, w = rgb.shape[:2]
+    return QImage(rgb.data, w, h, 3 * w, QImage.Format_RGB888).copy()
+
+
+class PickMode(Enum):
+    NONE = 0
+    POINT = 1
+    REGION = 2
+    TWO_POINTS = 3
+    COLOR = 4
+
+
+class PreviewLabel(QLabel):
+    pointPicked = Signal(QPoint)
+    regionSelected = Signal(QRect)
+    twoPointsPicked = Signal(QPoint, QPoint)
+    colorPicked = Signal(QPoint, QColor)
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self.setAlignment(Qt.AlignCenter)
+        self.setMinimumSize(320, 240)
+        self.setStyleSheet("background:#1e1e1e; color:#888;")
+        self.setText("(截图预览)")
+        self._img: Optional[np.ndarray] = None
+        self._orig: QPixmap = QPixmap()
+        self._mode = PickMode.NONE
+        self._rubber: Optional[QRubberBand] = None
+        self._press_pos: Optional[QPoint] = None
+        self._first_point: Optional[QPoint] = None
+        self._markers: list[tuple[int, int]] = []
+
+    # ---- image ----
+    def set_image_ndarray(self, bgr: np.ndarray) -> None:
+        self._img = bgr
+        self._orig = QPixmap.fromImage(ndarray_to_qimage(bgr))
+        self._markers.clear()
+        self._rescale()
+
+    def set_image_qimage(self, img: QImage) -> None:
+        self._img = None
+        self._orig = QPixmap.fromImage(img)
+        self._markers.clear()
+        self._rescale()
+
+    def has_image(self) -> bool:
+        return not self._orig.isNull()
+
+    def add_marker(self, x: int, y: int) -> None:
+        """Mark a hit at image-space (x, y); shown as a green ring on the preview."""
+        self._markers.append((int(x), int(y)))
+        self._rescale()
+
+    def clear_markers(self) -> None:
+        self._markers.clear()
+        self._rescale()
+
+    def _rescale(self) -> None:
+        if self._orig.isNull():
+            return
+        scaled = self._orig.scaled(self.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
+        if self._markers:
+            from PySide6.QtGui import QPainter, QPen, QColor
+            sx = scaled.width() / self._orig.width()
+            sy = scaled.height() / self._orig.height()
+            painter = QPainter(scaled)
+            painter.setPen(QPen(QColor(0, 255, 0), 2))
+            for mx, my in self._markers:
+                cx, cy = int(mx * sx), int(my * sy)
+                painter.drawEllipse(cx - 7, cy - 7, 14, 14)
+                painter.drawLine(cx - 10, cy, cx + 10, cy)
+                painter.drawLine(cx, cy - 10, cx, cy + 10)
+            painter.end()
+        self.setPixmap(scaled)
+
+    def resizeEvent(self, event) -> None:
+        self._rescale()
+        super().resizeEvent(event)
+
+    # ---- coordinate mapping ----
+    def _displayed_rect(self) -> QRect:
+        """Rect (in widget coords) where the scaled pixmap is actually drawn."""
+        if self._orig.isNull():
+            return QRect()
+        iw, ih = self._orig.width(), self._orig.height()
+        lw, lh = self.width(), self.height()
+        scale = min(lw / iw, lh / ih)
+        dw, dh = int(iw * scale), int(ih * scale)
+        return QRect((lw - dw) // 2, (lh - dh) // 2, dw, dh)
+
+    def _to_image(self, pos: QPoint) -> Optional[QPoint]:
+        rect = self._displayed_rect()
+        if rect.isEmpty() or not rect.contains(pos):
+            return None
+        iw, ih = self._orig.width(), self._orig.height()
+        ix = int((pos.x() - rect.x()) / rect.width() * iw)
+        iy = int((pos.y() - rect.y()) / rect.height() * ih)
+        return QPoint(max(0, min(iw - 1, ix)), max(0, min(ih - 1, iy)))
+
+    # ---- pick modes ----
+    def set_pick_mode(self, mode: PickMode) -> None:
+        self._mode = mode
+        self._first_point = None
+        self.setCursor(Qt.CrossCursor if mode != PickMode.NONE else Qt.ArrowCursor)
+
+    def mousePressEvent(self, event) -> None:
+        if self._orig.isNull() or event.button() != Qt.LeftButton:
+            return
+        img_pt = self._to_image(event.position().toPoint())
+        if img_pt is None:
+            return
+
+        if self._mode == PickMode.POINT:
+            self.pointPicked.emit(img_pt)
+        elif self._mode == PickMode.COLOR:
+            self.colorPicked.emit(img_pt, self._color_at(img_pt))
+        elif self._mode == PickMode.TWO_POINTS:
+            if self._first_point is None:
+                self._first_point = img_pt
+            else:
+                self.twoPointsPicked.emit(self._first_point, img_pt)
+                self._first_point = None
+                self.set_pick_mode(PickMode.NONE)
+        elif self._mode == PickMode.REGION:
+            self._press_pos = event.position().toPoint()
+            if self._rubber is None:
+                self._rubber = QRubberBand(QRubberBand.Rectangle, self)
+            self._rubber.setGeometry(QRect(self._press_pos, QSize()))
+            self._rubber.show()
+
+    def mouseMoveEvent(self, event) -> None:
+        if self._mode == PickMode.REGION and self._press_pos is not None and self._rubber:
+            self._rubber.setGeometry(QRect(self._press_pos, event.position().toPoint()).normalized())
+
+    def mouseReleaseEvent(self, event) -> None:
+        if self._mode == PickMode.REGION and self._press_pos is not None and self._rubber:
+            self._rubber.hide()
+            start = self._to_image(self._press_pos)
+            end = self._to_image(event.position().toPoint())
+            self._press_pos = None
+            if start and end:
+                rect = QRect(start, end).normalized()
+                if rect.width() > 2 and rect.height() > 2:
+                    self.regionSelected.emit(rect)
+            self.set_pick_mode(PickMode.NONE)
+
+    def _color_at(self, img_pt: QPoint) -> QColor:
+        if self._img is not None:
+            b, g, r = (int(v) for v in self._img[img_pt.y(), img_pt.x()][:3])
+            return QColor(r, g, b)
+        return QColor(self._orig.toImage().pixel(img_pt))

autoclicker/gui/qt_runner.py

@@ -0,0 +1,71 @@
+"""Qt adapter around the Qt-free TaskRunner engine.
+
+The engine runs on its own thread and invokes RunnerCallbacks; we re-emit those
+as Qt signals. Emitting a signal from the worker thread to a slot living in the
+GUI thread is delivered via a queued connection automatically, so the GUI stays
+responsive and thread-safe.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+
+from autoclicker.models import Task
+from autoclicker.runner import RunnerCallbacks, TaskRunner
+
+
+class _SignalCallbacks(RunnerCallbacks):
+    def __init__(self, owner: "QtRunner") -> None:
+        self._o = owner
+
+    def step_started(self, index, description):
+        self._o.stepStarted.emit(index, description)
+
+    def step_completed(self, index, success):
+        self._o.stepCompleted.emit(index, success)
+
+    def match_found(self, x, y, confidence):
+        self._o.matchFound.emit(x, y, confidence)
+
+    def log(self, msg):
+        self._o.logMessage.emit(msg)
+
+    def var_changed(self, name, value):
+        self._o.varChanged.emit(name, value)
+
+    def finished(self):
+        self._o.runFinished.emit()
+
+
+class QtRunner(QObject):
+    stepStarted = Signal(int, str)
+    stepCompleted = Signal(int, bool)
+    matchFound = Signal(int, int, float)
+    logMessage = Signal(str)
+    varChanged = Signal(str, str)
+    runFinished = Signal()
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self._runner: TaskRunner | None = None
+
+    def start(self, task: Task, target_hwnd=None, screenshot_on_fail=False, screenshot_dir=None) -> None:
+        self._runner = TaskRunner(task, target_hwnd=target_hwnd, callbacks=_SignalCallbacks(self))
+        self._runner.screenshot_on_fail = screenshot_on_fail
+        if screenshot_dir:
+            self._runner.screenshot_dir = screenshot_dir
+        self._runner.start()
+
+    def stop(self) -> None:
+        if self._runner:
+            self._runner.stop()
+
+    def pause(self) -> None:
+        if self._runner:
+            self._runner.pause()
+
+    def resume(self) -> None:
+        if self._runner:
+            self._runner.resume()
+
+    def is_running(self) -> bool:
+        return self._runner is not None and self._runner.is_alive()

autoclicker/gui/recorder.py

@@ -0,0 +1,163 @@
+"""Action recorder — port of recorder.cpp using pynput global hooks.
+
+Records left clicks / drags (client-relative to the target window) and key
+presses into Steps, inserting Wait steps for gaps >= 150ms. Emits stepRecorded
+from the listener thread; the signal is delivered to the GUI thread by Qt.
+"""
+from __future__ import annotations
+
+import math
+import time
+
+from PySide6.QtCore import QObject, Signal
+
+from autoclicker.models import Step, StepType
+
+try:
+    import win32gui
+    _HAS_WIN32 = True
+except ImportError:
+    _HAS_WIN32 = False
+
+from pynput import mouse, keyboard
+
+# pynput special key -> our key name (mirrors Recorder::vkToName specials)
+_SPECIAL_KEYS = {
+    keyboard.Key.enter: "ENTER", keyboard.Key.esc: "ESC", keyboard.Key.tab: "TAB",
+    keyboard.Key.space: "SPACE", keyboard.Key.backspace: "BACKSPACE",
+    keyboard.Key.delete: "DELETE", keyboard.Key.up: "UP", keyboard.Key.down: "DOWN",
+    keyboard.Key.left: "LEFT", keyboard.Key.right: "RIGHT", keyboard.Key.home: "HOME",
+    keyboard.Key.end: "END", keyboard.Key.page_up: "PAGEUP", keyboard.Key.page_down: "PAGEDOWN",
+}
+_MODIFIERS = {
+    keyboard.Key.ctrl, keyboard.Key.ctrl_l, keyboard.Key.ctrl_r,
+    keyboard.Key.shift, keyboard.Key.shift_l, keyboard.Key.shift_r,
+    keyboard.Key.alt, keyboard.Key.alt_l, keyboard.Key.alt_r, keyboard.Key.alt_gr,
+    keyboard.Key.cmd, keyboard.Key.cmd_l, keyboard.Key.cmd_r,
+}
+
+
+class Recorder(QObject):
+    stepRecorded = Signal(object)   # emits a Step
+    recordingStopped = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._hwnd = None
+        self._recording = False
+        self._mouse_listener = None
+        self._key_listener = None
+        self._t0 = 0.0
+        self._last_event = 0.0
+        self._down = False
+        self._down_pos = (0, 0)
+        self._down_time = 0.0
+
+    def is_recording(self) -> bool:
+        return self._recording
+
+    def start(self, hwnd):
+        if self._recording:
+            return
+        self._hwnd = hwnd
+        self._recording = True
+        self._t0 = time.monotonic()
+        self._last_event = 0.0
+        self._down = False
+        self._mouse_listener = mouse.Listener(on_click=self._on_click)
+        self._key_listener = keyboard.Listener(on_press=self._on_press)
+        self._mouse_listener.start()
+        self._key_listener.start()
+
+    def stop(self):
+        if not self._recording:
+            return
+        self._recording = False
+        if self._mouse_listener:
+            self._mouse_listener.stop()
+            self._mouse_listener = None
+        if self._key_listener:
+            self._key_listener.stop()
+            self._key_listener = None
+        self.recordingStopped.emit()
+
+    # ---- helpers ----
+    def _elapsed_ms(self) -> float:
+        return (time.monotonic() - self._t0) * 1000.0
+
+    def _inside(self, x, y) -> bool:
+        if not _HAS_WIN32 or not self._hwnd:
+            return True
+        try:
+            l, t, r, b = win32gui.GetWindowRect(self._hwnd)
+        except Exception:
+            return False
+        return l <= x <= r and t <= y <= b
+
+    def _to_client(self, x, y):
+        if _HAS_WIN32 and self._hwnd:
+            try:
+                return win32gui.ScreenToClient(self._hwnd, (x, y))
+            except Exception:
+                return x, y
+        return x, y
+
+    def _emit_wait_if_needed(self):
+        now = self._elapsed_ms()
+        if self._last_event > 0:
+            gap = int(now - self._last_event)
+            if gap >= 150:
+                self.stepRecorded.emit(Step(type=StepType.Wait, waitMs=gap))
+        self._last_event = now
+
+    # ---- pynput callbacks (run on listener thread) ----
+    def _on_click(self, x, y, button, pressed):
+        if not self._recording or button != mouse.Button.left:
+            return
+        if not self._inside(x, y):
+            return
+        cx, cy = self._to_client(x, y)
+        if pressed:
+            self._down = True
+            self._down_pos = (cx, cy)
+            self._down_time = self._elapsed_ms()
+        elif self._down:
+            self._down = False
+            dx, dy = cx - self._down_pos[0], cy - self._down_pos[1]
+            dist = math.hypot(dx, dy)
+            self._emit_wait_if_needed()
+            if dist > 10:
+                dur = int(self._elapsed_ms() - self._down_time)
+                self.stepRecorded.emit(Step(type=StepType.Drag,
+                                            x=self._down_pos[0], y=self._down_pos[1],
+                                            x2=cx, y2=cy, durationMs=dur if dur >= 50 else 200))
+            else:
+                self.stepRecorded.emit(Step(type=StepType.ClickPosition, x=cx, y=cy))
+
+    def _on_press(self, key):
+        if not self._recording or key in _MODIFIERS:
+            return
+        if _HAS_WIN32 and self._hwnd:
+            try:
+                if win32gui.GetForegroundWindow() != self._hwnd:
+                    return
+            except Exception:
+                pass
+        name = self._key_name(key)
+        if name:
+            self._emit_wait_if_needed()
+            self.stepRecorded.emit(Step(type=StepType.KeyPress, keyName=name))
+
+    @staticmethod
+    def _key_name(key) -> str:
+        if key in _SPECIAL_KEYS:
+            return _SPECIAL_KEYS[key]
+        if isinstance(key, keyboard.Key):
+            k = str(key).replace("Key.", "")
+            if k.startswith("f") and k[1:].isdigit():
+                return k.upper()
+            return ""
+        ch = getattr(key, "char", None)
+        if ch and (ch.isalnum()):
+            return ch.upper()
+        return ""

autoclicker/gui/scheduler_widget.py

@@ -0,0 +1,160 @@
+"""Scheduled-task list — port of schedulerwidget.cpp.
+
+Runs saved .json task files on a fixed interval. Persists via QSettings under
+the same ("AutoClicker","AutoClicker") key as the C++ app, so schedules are
+shared between the two versions.
+"""
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+
+from PySide6.QtCore import QTimer, Signal
+from PySide6.QtWidgets import (
+    QComboBox, QDialog, QDialogButtonBox, QFileDialog, QFormLayout, QHBoxLayout,
+    QLabel, QLineEdit, QListWidget, QPushButton, QSpinBox, QVBoxLayout, QWidget,
+)
+from PySide6.QtCore import QSettings
+
+
+@dataclass
+class ScheduledTask:
+    name: str = ""
+    task_path: str = ""
+    interval_ms: int = 600000
+    enabled: bool = True
+    next_run: float = 0.0   # monotonic seconds
+
+
+class SchedulerWidget(QWidget):
+    runTaskRequested = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._tasks: list[ScheduledTask] = []
+
+        lay = QVBoxLayout(self)
+        hint = QLabel("定时任务列表 — 自动按间隔执行已保存的任务文件")
+        hint.setStyleSheet("color: gray;")
+        lay.addWidget(hint)
+        self.list = QListWidget()
+        lay.addWidget(self.list)
+        row = QHBoxLayout()
+        for text, slot in [("添加定时任务", self._add), ("启用/禁用", self._toggle), ("删除", self._remove)]:
+            b = QPushButton(text)
+            b.clicked.connect(slot)
+            row.addWidget(b)
+        lay.addLayout(row)
+
+        self._timer = QTimer(self)
+        self._timer.setInterval(1000)
+        self._timer.timeout.connect(self._tick)
+        self._timer.start()
+        self._load_settings()
+
+    def _add(self):
+        dlg = QDialog(self)
+        dlg.setWindowTitle("添加定时任务")
+        dlg.setMinimumWidth(400)
+        form = QFormLayout(dlg)
+        path_edit = QLineEdit()
+        browse = QPushButton("浏览…")
+        prow = QHBoxLayout()
+        prow.addWidget(path_edit)
+        prow.addWidget(browse)
+        browse.clicked.connect(lambda: self._pick_path(dlg, path_edit))
+        form.addRow("任务文件:", prow)
+        interval = QSpinBox()
+        interval.setRange(1, 9999)
+        interval.setValue(10)
+        form.addRow("间隔:", interval)
+        unit = QComboBox()
+        unit.addItem("秒", 1000)
+        unit.addItem("分钟", 60000)
+        unit.addItem("小时", 3600000)
+        unit.setCurrentIndex(1)
+        form.addRow("单位:", unit)
+        bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        bb.accepted.connect(dlg.accept)
+        bb.rejected.connect(dlg.reject)
+        form.addRow(bb)
+        if dlg.exec() != QDialog.Accepted or not path_edit.text():
+            return
+        interval_ms = interval.value() * unit.currentData()
+        t = ScheduledTask(name=os.path.splitext(os.path.basename(path_edit.text()))[0],
+                          task_path=path_edit.text(), interval_ms=interval_ms, enabled=True,
+                          next_run=time.monotonic() + interval_ms / 1000.0)
+        self._tasks.append(t)
+        self._save_settings()
+        self._refresh()
+
+    def _pick_path(self, dlg, edit):
+        p, _ = QFileDialog.getOpenFileName(dlg, "选择任务文件", "", "JSON (*.json)")
+        if p:
+            edit.setText(p)
+
+    def _remove(self):
+        row = self.list.currentRow()
+        if 0 <= row < len(self._tasks):
+            del self._tasks[row]
+            self._save_settings()
+            self._refresh()
+
+    def _toggle(self):
+        row = self.list.currentRow()
+        if 0 <= row < len(self._tasks):
+            t = self._tasks[row]
+            t.enabled = not t.enabled
+            if t.enabled:
+                t.next_run = time.monotonic() + t.interval_ms / 1000.0
+            self._save_settings()
+            self._refresh()
+
+    def _tick(self):
+        now = time.monotonic()
+        for t in self._tasks:
+            if t.enabled and now >= t.next_run:
+                self.runTaskRequested.emit(t.task_path)
+                t.next_run = now + t.interval_ms / 1000.0
+
+    def _refresh(self):
+        self.list.clear()
+        for t in self._tasks:
+            secs = t.interval_ms // 1000
+            interval = (f"{secs // 3600}小时" if secs >= 3600
+                        else f"{secs // 60}分钟" if secs >= 60 else f"{secs}秒")
+            status = "[启用]" if t.enabled else "[禁用]"
+            self.list.addItem(f"{status} {t.name} — 每{interval}")
+
+    # ---- persistence (QSettings, shared with C++) ----
+    def _load_settings(self):
+        s = QSettings("AutoClicker", "AutoClicker")
+        n = s.beginReadArray("scheduledTasks")
+        self._tasks.clear()
+        for i in range(n):
+            s.setArrayIndex(i)
+            interval_ms = int(s.value("interval", 600000))
+            self._tasks.append(ScheduledTask(
+                name=s.value("name", ""), task_path=s.value("path", ""),
+                interval_ms=interval_ms, enabled=_as_bool(s.value("enabled", True)),
+                next_run=time.monotonic() + interval_ms / 1000.0))
+        s.endArray()
+        self._refresh()
+
+    def _save_settings(self):
+        s = QSettings("AutoClicker", "AutoClicker")
+        s.beginWriteArray("scheduledTasks", len(self._tasks))
+        for i, t in enumerate(self._tasks):
+            s.setArrayIndex(i)
+            s.setValue("name", t.name)
+            s.setValue("path", t.task_path)
+            s.setValue("interval", t.interval_ms)
+            s.setValue("enabled", t.enabled)
+        s.endArray()
+
+
+def _as_bool(v) -> bool:
+    if isinstance(v, bool):
+        return v
+    return str(v).lower() in ("1", "true", "yes")