mouse-keepalive 1.5.2__tar.gz

mouse_keepalive-1.5.2/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 motoish
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

mouse_keepalive-1.5.2/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include src/mouse_keepalive *.py

mouse_keepalive-1.5.2/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: mouse-keepalive
+Version: 1.5.2
+Summary: A cross-platform tool to automatically move the mouse at specified intervals to prevent system sleep or lock
+Author: motoish
+License: MIT
+Project-URL: Homepage, https://github.com/motoish/mouse-keepalive
+Project-URL: Documentation, https://github.com/motoish/mouse-keepalive#readme
+Project-URL: Repository, https://github.com/motoish/mouse-keepalive
+Project-URL: Issues, https://github.com/motoish/mouse-keepalive/issues
+Keywords: mouse,automation,prevent-sleep,idle,keep-alive,cross-platform,cli,tool,macos,windows,linux
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyautogui>=0.9.54
+Provides-Extra: dev
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: yamllint>=1.32.0; extra == "dev"
+Dynamic: license-file
+
+# Mouse Keepalive
+
+**中文** | [English](README_EN.md)
+
+跨平台 CLI 工具：按固定间隔轻微移动鼠标并立即回位，避免系统因长时间无操作而休眠或锁屏。  
+支持 **macOS / Windows / Linux**。
+
+---
+
+## ✨ 功能亮点
+
+- 跨平台（Python + [pyautogui](https://pypi.org/project/PyAutoGUI/)）
+- 可配置移动间隔与总运行时长
+- 瞬时微移（约 1–2 像素），日常使用几乎无感
+- **PyPI** 与 **npm** 均可安装；命令行别名 `mka`
+- 默认输出每次移动日志；`-q` 可完全静默
+
+---
+
+## 📋 环境要求
+
+| 方式 | 要求 |
+|------|------|
+| **PyPI / pipx**（推荐） | Python **3.11+** |
+| **npm** | Node.js **14+**，且本机已安装 **Python 3.11+**（npm 包为启动器，实际逻辑在 Python 中） |
+| **从源码运行** | Python 3.11+；见下方「本地开发」 |
+
+---
+
+## 📦 安装
+
+### PyPI（推荐）
+
+```bash
+pip install mouse-keepalive
+# 或（隔离环境，推荐桌面使用）
+pipx install mouse-keepalive
+```
+
+### npm
+
+```bash
+npm install -g mouse-keepalive
+```
+
+首次运行前请确保已安装 Python 3.11+；若缺少 `pyautogui`，npm 入口会尝试自动 `pip install pyautogui`。
+
+---
+
+## 🚀 快速开始
+
+```bash
+# 默认：每 60 秒移动一次，Ctrl+C 停止
+mka
+
+# 每 30 秒移动一次
+mka -i 30
+
+# 每 2 分钟移动一次，共运行 1 小时
+mka -i 120 -d 3600
+
+# 静默模式（无日志）
+mka -q
+
+# 帮助
+mka --help
+```
+
+等效命令：
+
+```text
+mouse-keepalive
+python -m mouse_keepalive
+```
+
+---
+
+## ⚙️ 命令行参数
+
+| 参数 | 说明 | 默认 |
+|------|------|------|
+| `-i, --interval` | 移动间隔（秒） | `60` |
+| `-d, --duration` | 运行总时长（秒）；省略则一直运行 | 无限 |
+| `-q, --quiet` | 静默模式，不输出日志 | 关闭 |
+| `-h, --help` | 显示帮助 | — |
+
+---
+
+## 🧠 工作原理
+
+程序按间隔获取当前光标位置，偏移 1–2 像素后**立即移回**，使系统仍检测到鼠标活动，同时尽量不打扰正常使用。
+
+---
+
+## 🛠 本地开发
+
+仓库采用 **src 布局**，包路径为 `src/mouse_keepalive/`（对外导入名仍为 `mouse_keepalive`）。
+
+```bash
+git clone https://github.com/motoish/mouse-keepalive.git
+cd mouse-keepalive
+
+# 可编辑安装 + 开发依赖
+pip install -e ".[dev]"
+
+# 方式一：仓库根目录脚本（改代码后无需重装）
+./move_mouse.sh
+./move_mouse.sh -i 30 -q
+
+# 方式二：Makefile
+make run ARGS="-i 30"
+
+# 方式三：安装后的 CLI
+mka -i 30
+
+# 测试与检查
+make test
+make lint
+```
+
+`move_mouse.sh` 会优先使用 `.venv/bin/python`，并通过 `PYTHONPATH=src` 加载源码；**不会**随 PyPI/npm 包发布。
+
+### 目录结构（简要）
+
+```text
+mouse-keepalive/
+├── src/mouse_keepalive/   # Python 包
+├── bin/                   # npm CLI（转发到 python -m mouse_keepalive）
+├── tests/
+├── move_mouse.sh          # 仅本地开发
+└── pyproject.toml
+```
+
+---
+
+## ⚠️ 注意事项
+
+- 使用 **Ctrl + C** 可随时退出  
+- **macOS** 需在「系统设置 → 隐私与安全性 → 辅助功能」中允许终端或 Python  
+- 企业安全策略可能拦截模拟鼠标；若无效请联系管理员或加入白名单  
+
+---
+
+## 📦 发布与版本
+
+用户安装版本以 [PyPI](https://pypi.org/project/mouse-keepalive/) / [npm](https://www.npmjs.com/package/mouse-keepalive) 为准。  
+变更记录见 [CHANGELOG.md](CHANGELOG.md)。仓库使用 [release-please](https://github.com/googleapis/release-please) 管理版本；合并 Release PR 后会发布 `v*` 标签并自动发布到 npm / PyPI。
+
+---
+
+## 📄 许可证
+
+[MIT](LICENSE)

mouse_keepalive-1.5.2/README.md

@@ -0,0 +1,153 @@
+# Mouse Keepalive
+
+**中文** | [English](README_EN.md)
+
+跨平台 CLI 工具：按固定间隔轻微移动鼠标并立即回位，避免系统因长时间无操作而休眠或锁屏。  
+支持 **macOS / Windows / Linux**。
+
+---
+
+## ✨ 功能亮点
+
+- 跨平台（Python + [pyautogui](https://pypi.org/project/PyAutoGUI/)）
+- 可配置移动间隔与总运行时长
+- 瞬时微移（约 1–2 像素），日常使用几乎无感
+- **PyPI** 与 **npm** 均可安装；命令行别名 `mka`
+- 默认输出每次移动日志；`-q` 可完全静默
+
+---
+
+## 📋 环境要求
+
+| 方式 | 要求 |
+|------|------|
+| **PyPI / pipx**（推荐） | Python **3.11+** |
+| **npm** | Node.js **14+**，且本机已安装 **Python 3.11+**（npm 包为启动器，实际逻辑在 Python 中） |
+| **从源码运行** | Python 3.11+；见下方「本地开发」 |
+
+---
+
+## 📦 安装
+
+### PyPI（推荐）
+
+```bash
+pip install mouse-keepalive
+# 或（隔离环境，推荐桌面使用）
+pipx install mouse-keepalive
+```
+
+### npm
+
+```bash
+npm install -g mouse-keepalive
+```
+
+首次运行前请确保已安装 Python 3.11+；若缺少 `pyautogui`，npm 入口会尝试自动 `pip install pyautogui`。
+
+---
+
+## 🚀 快速开始
+
+```bash
+# 默认：每 60 秒移动一次，Ctrl+C 停止
+mka
+
+# 每 30 秒移动一次
+mka -i 30
+
+# 每 2 分钟移动一次，共运行 1 小时
+mka -i 120 -d 3600
+
+# 静默模式（无日志）
+mka -q
+
+# 帮助
+mka --help
+```
+
+等效命令：
+
+```text
+mouse-keepalive
+python -m mouse_keepalive
+```
+
+---
+
+## ⚙️ 命令行参数
+
+| 参数 | 说明 | 默认 |
+|------|------|------|
+| `-i, --interval` | 移动间隔（秒） | `60` |
+| `-d, --duration` | 运行总时长（秒）；省略则一直运行 | 无限 |
+| `-q, --quiet` | 静默模式，不输出日志 | 关闭 |
+| `-h, --help` | 显示帮助 | — |
+
+---
+
+## 🧠 工作原理
+
+程序按间隔获取当前光标位置，偏移 1–2 像素后**立即移回**，使系统仍检测到鼠标活动，同时尽量不打扰正常使用。
+
+---
+
+## 🛠 本地开发
+
+仓库采用 **src 布局**，包路径为 `src/mouse_keepalive/`（对外导入名仍为 `mouse_keepalive`）。
+
+```bash
+git clone https://github.com/motoish/mouse-keepalive.git
+cd mouse-keepalive
+
+# 可编辑安装 + 开发依赖
+pip install -e ".[dev]"
+
+# 方式一：仓库根目录脚本（改代码后无需重装）
+./move_mouse.sh
+./move_mouse.sh -i 30 -q
+
+# 方式二：Makefile
+make run ARGS="-i 30"
+
+# 方式三：安装后的 CLI
+mka -i 30
+
+# 测试与检查
+make test
+make lint
+```
+
+`move_mouse.sh` 会优先使用 `.venv/bin/python`，并通过 `PYTHONPATH=src` 加载源码；**不会**随 PyPI/npm 包发布。
+
+### 目录结构（简要）
+
+```text
+mouse-keepalive/
+├── src/mouse_keepalive/   # Python 包
+├── bin/                   # npm CLI（转发到 python -m mouse_keepalive）
+├── tests/
+├── move_mouse.sh          # 仅本地开发
+└── pyproject.toml
+```
+
+---
+
+## ⚠️ 注意事项
+
+- 使用 **Ctrl + C** 可随时退出  
+- **macOS** 需在「系统设置 → 隐私与安全性 → 辅助功能」中允许终端或 Python  
+- 企业安全策略可能拦截模拟鼠标；若无效请联系管理员或加入白名单  
+
+---
+
+## 📦 发布与版本
+
+用户安装版本以 [PyPI](https://pypi.org/project/mouse-keepalive/) / [npm](https://www.npmjs.com/package/mouse-keepalive) 为准。  
+变更记录见 [CHANGELOG.md](CHANGELOG.md)。仓库使用 [release-please](https://github.com/googleapis/release-please) 管理版本；合并 Release PR 后会发布 `v*` 标签并自动发布到 npm / PyPI。
+
+---
+
+## 📄 许可证
+
+[MIT](LICENSE)

mouse_keepalive-1.5.2/pyproject.toml

@@ -0,0 +1,108 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mouse-keepalive"
+version = "1.5.2"
+description = "A cross-platform tool to automatically move the mouse at specified intervals to prevent system sleep or lock"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "motoish"}
+]
+keywords = [
+    "mouse",
+    "automation",
+    "prevent-sleep",
+    "idle",
+    "keep-alive",
+    "cross-platform",
+    "cli",
+    "tool",
+    "macos",
+    "windows",
+    "linux"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Hardware",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "pyautogui>=0.9.54",
+]
+
+[project.optional-dependencies]
+dev = [
+    "flake8>=6.0.0",
+    "black>=23.0.0",
+    "pylint>=2.17.0",
+    "mypy>=1.0.0",
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "yamllint>=1.32.0",
+]
+
+[project.scripts]
+mouse-keepalive = "mouse_keepalive.move_mouse:main"
+mka = "mouse_keepalive.move_mouse:main"
+
+[project.urls]
+Homepage = "https://github.com/motoish/mouse-keepalive"
+Documentation = "https://github.com/motoish/mouse-keepalive#readme"
+Repository = "https://github.com/motoish/mouse-keepalive"
+Issues = "https://github.com/motoish/mouse-keepalive/issues"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 120
+target-version = ['py311']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+disallow_untyped_defs = false
+no_implicit_optional = true
+
+[[tool.mypy.overrides]]
+module = "pyautogui.*"
+ignore_missing_imports = true
+

mouse_keepalive-1.5.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mouse_keepalive-1.5.2/src/mouse_keepalive/__init__.py

@@ -0,0 +1,16 @@
+"""
+自动移动鼠标工具 / Mouse Keepalive Tool
+支持 macOS、Windows 和 Linux 系统 / Supports macOS, Windows and Linux
+
+模块化架构：
+- 核心逻辑在 move_mouse 模块中实现
+- 所有入口点（CLI、模块调用）都使用相同的核心逻辑
+- 支持依赖注入，便于测试
+"""
+
+__version__ = "1.5.2"
+__author__ = "motoish"
+
+from .move_mouse import move_mouse, main, MouseMover, MouseController, MousePosition, ScreenSize
+
+__all__ = ["move_mouse", "main", "MouseMover", "MouseController", "MousePosition", "ScreenSize"]

mouse_keepalive-1.5.2/src/mouse_keepalive/__main__.py

@@ -0,0 +1,9 @@
+"""
+命令行入口点 / Command Line Entry Point
+允许使用 python -m mouse_keepalive 运行 / Allows running with python -m mouse_keepalive
+"""
+
+from .move_mouse import main
+
+if __name__ == "__main__":
+    main()

mouse_keepalive-1.5.2/src/mouse_keepalive/move_mouse.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""
+自动移动鼠标脚本 / Mouse Keepalive Script
+支持 macOS、Windows 和 Linux 系统 / Supports macOS, Windows and Linux
+"""
+
+import argparse
+import sys
+import time
+import platform
+from typing import Optional, Callable, Tuple
+from dataclasses import dataclass
+
+try:
+    import pyautogui
+except ImportError:
+    print("错误: 未安装 pyautogui 库")
+    print("Error: pyautogui library not installed")
+    print("请运行: pip install pyautogui")
+    print("Please run: pip install pyautogui")
+    sys.exit(1)
+
+# 禁用 pyautogui 的安全功能（防止鼠标移到屏幕角落时停止）
+# Disable pyautogui failsafe (prevents stopping when mouse moves to screen corner)
+pyautogui.FAILSAFE = False
+
+
+@dataclass
+class MousePosition:
+    """鼠标位置数据类 / Mouse position data class"""
+
+    x: int
+    y: int
+
+
+@dataclass
+class ScreenSize:
+    """屏幕尺寸数据类 / Screen size data class"""
+
+    width: int
+    height: int
+
+
+class MouseController:
+    """
+    鼠标控制器接口 / Mouse controller interface
+    封装鼠标操作，便于测试时替换实现
+    """
+
+    def get_position(self) -> MousePosition:
+        """获取当前鼠标位置 / Get current mouse position"""
+        x, y = pyautogui.position()
+        return MousePosition(x, y)
+
+    def get_screen_size(self) -> ScreenSize:
+        """获取屏幕尺寸 / Get screen size"""
+        width, height = pyautogui.size()
+        return ScreenSize(width, height)
+
+    def move_to(self, x: int, y: int, duration: float = 0) -> None:
+        """移动鼠标到指定位置 / Move mouse to specified position"""
+        pyautogui.moveTo(x, y, duration=duration)
+
+
+class MouseMover:
+    """
+    核心鼠标移动逻辑类 / Core mouse movement logic class
+    这个类包含所有核心逻辑，不依赖具体的 I/O 实现，便于测试
+    """
+
+    def __init__(
+        self,
+        controller: Optional[MouseController] = None,
+        time_func: Optional[Callable[[], float]] = None,
+        sleep_func: Optional[Callable[[float], None]] = None,
+        print_func: Optional[Callable[[str], None]] = None,
+    ):
+        """
+        初始化鼠标移动器 / Initialize mouse mover
+
+        Args:
+            controller: 鼠标控制器，默认使用真实实现 / Mouse controller, defaults to real implementation
+            time_func: 时间函数，默认使用 time.time / Time function, defaults to time.time
+            sleep_func: 睡眠函数，默认使用 time.sleep / Sleep function, defaults to time.sleep
+            print_func: 打印函数，默认使用 print / Print function, defaults to print
+        """
+        self.controller = controller or MouseController()
+        self.time_func = time_func or time.time
+        self.sleep_func = sleep_func or time.sleep
+        self.print_func = print_func or print
+
+    def calculate_next_position(
+        self, current_pos: MousePosition, screen_size: ScreenSize, move_count: int
+    ) -> Tuple[int, int]:
+        """
+        计算下一个鼠标位置 / Calculate next mouse position
+
+        Args:
+            current_pos: 当前鼠标位置 / Current mouse position
+            screen_size: 屏幕尺寸 / Screen size
+            move_count: 移动计数（用于交替方向）/ Move count (for alternating direction)
+
+        Returns:
+            下一个位置的 (x, y) 坐标 / Next position (x, y) coordinates
+        """
+        # 移动鼠标到稍微不同的位置（移动1-2像素）
+        # Move mouse to slightly different position (move 1-2 pixels)
+        offset_x = 1 if move_count % 2 == 0 else -1
+        offset_y = 1 if move_count % 2 == 0 else -1
+
+        new_x = current_pos.x + offset_x
+        new_y = current_pos.y + offset_y
+
+        # 确保坐标在屏幕范围内 / Ensure coordinates are within screen bounds
+        new_x = max(1, min(new_x, screen_size.width - 1))
+        new_y = max(1, min(new_y, screen_size.height - 1))
+
+        return new_x, new_y
+
+    def perform_move(self, move_count: int) -> Tuple[MousePosition, int]:
+        """
+        执行一次鼠标移动 / Perform one mouse movement
+
+        Args:
+            move_count: 当前移动计数 / Current move count
+
+        Returns:
+            (原始位置, 新的移动计数) / (Original position, new move count)
+        """
+        # 获取当前鼠标位置 / Get current mouse position
+        current_pos = self.controller.get_position()
+
+        # 获取屏幕尺寸 / Get screen size
+        screen_size = self.controller.get_screen_size()
+
+        # 计算下一个位置 / Calculate next position
+        new_x, new_y = self.calculate_next_position(current_pos, screen_size, move_count)
+
+        # 移动鼠标 / Move mouse
+        self.controller.move_to(new_x, new_y, duration=0)
+        move_count += 1
+
+        # 立即移回原位置（这样用户感觉不到鼠标移动）
+        # Immediately move back to original position (user won't notice the movement)
+        self.controller.move_to(current_pos.x, current_pos.y, duration=0)
+
+        return current_pos, move_count
+
+    def run(
+        self,
+        interval: int = 60,
+        duration: Optional[int] = None,
+        *,
+        on_start: Optional[Callable[[], None]] = None,
+        on_move: Optional[Callable[[int, MousePosition, float], None]] = None,
+        on_finish: Optional[Callable[[int, float], None]] = None,
+    ) -> Tuple[int, float]:
+        """
+        运行鼠标移动循环 / Run mouse movement loop
+
+        Args:
+            interval: 移动间隔（秒）/ Movement interval (seconds)
+            duration: 运行时长（秒），None 表示无限运行 / Duration (seconds), None means infinite
+            on_start: 启动回调函数 / Start callback function
+            on_move: 移动回调函数 / Move callback function
+            on_finish: 完成回调函数 / Finish callback function
+
+        Returns:
+            (移动次数, 运行时长) / (Move count, duration)
+        """
+        if on_start:
+            on_start()
+
+        start_time = self.time_func()
+        move_count = 0
+
+        try:
+            while True:
+                # 执行移动 / Perform move
+                current_pos, move_count = self.perform_move(move_count)
+
+                elapsed = self.time_func() - start_time
+
+                if on_move:
+                    on_move(move_count, current_pos, elapsed)
+
+                # 检查是否达到运行时长 / Check if duration is reached
+                if duration and elapsed >= duration:
+                    if on_finish:
+                        on_finish(move_count, elapsed)
+                    break
+
+                # 等待指定间隔 / Wait for specified interval
+                self.sleep_func(interval)
+
+        except KeyboardInterrupt:
+            elapsed = self.time_func() - start_time
+            if on_finish:
+                on_finish(move_count, elapsed)
+            raise
+
+        elapsed = self.time_func() - start_time
+        return move_count, elapsed
+
+
+def _make_log_callbacks(
+    mover: MouseMover,
+    interval: int,
+    duration: Optional[int],
+    quiet: bool,
+) -> Tuple[
+    Optional[Callable[[], None]],
+    Optional[Callable[[int, MousePosition, float], None]],
+    Optional[Callable[[int, float], None]],
+]:
+    """构建日志回调；静默模式返回 (None, None, None)。"""
+    if quiet:
+        return None, None, None
+
+    def on_start() -> None:
+        mover.print_func("开始自动移动鼠标... / Starting mouse keepalive...")
+        mover.print_func(f"间隔 {interval}s" + (f"，时长 {duration}s" if duration else "，无限运行（Ctrl+C 停止）"))
+        mover.print_func(f"OS: {platform.system()}")
+        mover.print_func("-" * 50)
+
+    def on_move(move_count: int, current_pos: MousePosition, elapsed: float) -> None:
+        mover.print_func(f"[{int(elapsed)}s] 已移动 {move_count} 次 " f"(位置: {current_pos.x}, {current_pos.y})")
+
+    def on_finish(move_count: int, elapsed: float) -> None:
+        if duration:
+            mover.print_func(f"\n已达运行时长 {duration}s，共移动 {move_count} 次")
+        else:
+            mover.print_func(f"\n已停止，共移动 {move_count} 次，运行 {int(elapsed)}s")
+
+    return on_start, on_move, on_finish
+
+
+def move_mouse(interval: int = 60, duration: Optional[int] = None, quiet: bool = False) -> None:
+    """
+    自动移动鼠标 / Automatically move mouse
+    这是主要的公共 API，保持向后兼容性
+
+    Args:
+        interval: 移动间隔（秒），默认60秒 / Movement interval (seconds), default 60
+        duration: 运行时长（秒），None表示无限运行 / Duration (seconds), None means infinite
+        quiet: 静默模式，不输出日志 / Quiet mode, no log output
+    """
+    mover = MouseMover()
+    on_start, on_move, on_finish = _make_log_callbacks(mover, interval, duration, quiet)
+
+    try:
+        mover.run(
+            interval=interval,
+            duration=duration,
+            on_start=on_start,
+            on_move=on_move,
+            on_finish=on_finish,
+        )
+    except KeyboardInterrupt:
+        # on_finish 已经在 KeyboardInterrupt 处理中调用
+        pass
+
+
+def main():
+    """命令行入口函数 / Command line entry function"""
+    parser = argparse.ArgumentParser(
+        description="自动移动鼠标工具（防止系统进入休眠或锁定） / Mouse keepalive tool (prevents system sleep or lock)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例 / Examples:
+  mouse-keepalive                    # 每60秒移动一次，无限运行 / Move every 60s, infinite
+  mouse-keepalive -i 30              # 每30秒移动一次 / Move every 30s
+  mouse-keepalive -i 120 -d 3600     # 每120秒移动一次，运行1小时 / Move every 120s, run for 1 hour
+  mouse-keepalive -q                 # 静默模式 / Quiet mode
+  mka -i 30                          # 使用简短别名 / Use short alias
+  python -m mouse_keepalive         # 使用模块方式运行 / Run as module
+        """,
+    )
+
+    parser.add_argument(
+        "-i",
+        "--interval",
+        type=int,
+        default=60,
+        help="鼠标移动间隔（秒），默认60秒 / Mouse movement interval (seconds), default 60",
+    )
+
+    parser.add_argument(
+        "-d",
+        "--duration",
+        type=int,
+        default=None,
+        help="运行时长（秒），默认无限运行 / Duration (seconds), default infinite",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="静默模式，不输出日志 / Quiet mode, no log output",
+    )
+
+    args = parser.parse_args()
+
+    if args.interval < 1:
+        print("错误: 移动间隔必须大于0")
+        print("Error: Interval must be greater than 0")
+        sys.exit(1)
+
+    if args.duration is not None and args.duration < 1:
+        print("错误: 运行时长必须大于0")
+        print("Error: Duration must be greater than 0")
+        sys.exit(1)
+
+    move_mouse(interval=args.interval, duration=args.duration, quiet=args.quiet)
+
+
+if __name__ == "__main__":
+    main()

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: mouse-keepalive
+Version: 1.5.2
+Summary: A cross-platform tool to automatically move the mouse at specified intervals to prevent system sleep or lock
+Author: motoish
+License: MIT
+Project-URL: Homepage, https://github.com/motoish/mouse-keepalive
+Project-URL: Documentation, https://github.com/motoish/mouse-keepalive#readme
+Project-URL: Repository, https://github.com/motoish/mouse-keepalive
+Project-URL: Issues, https://github.com/motoish/mouse-keepalive/issues
+Keywords: mouse,automation,prevent-sleep,idle,keep-alive,cross-platform,cli,tool,macos,windows,linux
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyautogui>=0.9.54
+Provides-Extra: dev
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: yamllint>=1.32.0; extra == "dev"
+Dynamic: license-file
+
+# Mouse Keepalive
+
+**中文** | [English](README_EN.md)
+
+跨平台 CLI 工具：按固定间隔轻微移动鼠标并立即回位，避免系统因长时间无操作而休眠或锁屏。  
+支持 **macOS / Windows / Linux**。
+
+---
+
+## ✨ 功能亮点
+
+- 跨平台（Python + [pyautogui](https://pypi.org/project/PyAutoGUI/)）
+- 可配置移动间隔与总运行时长
+- 瞬时微移（约 1–2 像素），日常使用几乎无感
+- **PyPI** 与 **npm** 均可安装；命令行别名 `mka`
+- 默认输出每次移动日志；`-q` 可完全静默
+
+---
+
+## 📋 环境要求
+
+| 方式 | 要求 |
+|------|------|
+| **PyPI / pipx**（推荐） | Python **3.11+** |
+| **npm** | Node.js **14+**，且本机已安装 **Python 3.11+**（npm 包为启动器，实际逻辑在 Python 中） |
+| **从源码运行** | Python 3.11+；见下方「本地开发」 |
+
+---
+
+## 📦 安装
+
+### PyPI（推荐）
+
+```bash
+pip install mouse-keepalive
+# 或（隔离环境，推荐桌面使用）
+pipx install mouse-keepalive
+```
+
+### npm
+
+```bash
+npm install -g mouse-keepalive
+```
+
+首次运行前请确保已安装 Python 3.11+；若缺少 `pyautogui`，npm 入口会尝试自动 `pip install pyautogui`。
+
+---
+
+## 🚀 快速开始
+
+```bash
+# 默认：每 60 秒移动一次，Ctrl+C 停止
+mka
+
+# 每 30 秒移动一次
+mka -i 30
+
+# 每 2 分钟移动一次，共运行 1 小时
+mka -i 120 -d 3600
+
+# 静默模式（无日志）
+mka -q
+
+# 帮助
+mka --help
+```
+
+等效命令：
+
+```text
+mouse-keepalive
+python -m mouse_keepalive
+```
+
+---
+
+## ⚙️ 命令行参数
+
+| 参数 | 说明 | 默认 |
+|------|------|------|
+| `-i, --interval` | 移动间隔（秒） | `60` |
+| `-d, --duration` | 运行总时长（秒）；省略则一直运行 | 无限 |
+| `-q, --quiet` | 静默模式，不输出日志 | 关闭 |
+| `-h, --help` | 显示帮助 | — |
+
+---
+
+## 🧠 工作原理
+
+程序按间隔获取当前光标位置，偏移 1–2 像素后**立即移回**，使系统仍检测到鼠标活动，同时尽量不打扰正常使用。
+
+---
+
+## 🛠 本地开发
+
+仓库采用 **src 布局**，包路径为 `src/mouse_keepalive/`（对外导入名仍为 `mouse_keepalive`）。
+
+```bash
+git clone https://github.com/motoish/mouse-keepalive.git
+cd mouse-keepalive
+
+# 可编辑安装 + 开发依赖
+pip install -e ".[dev]"
+
+# 方式一：仓库根目录脚本（改代码后无需重装）
+./move_mouse.sh
+./move_mouse.sh -i 30 -q
+
+# 方式二：Makefile
+make run ARGS="-i 30"
+
+# 方式三：安装后的 CLI
+mka -i 30
+
+# 测试与检查
+make test
+make lint
+```
+
+`move_mouse.sh` 会优先使用 `.venv/bin/python`，并通过 `PYTHONPATH=src` 加载源码；**不会**随 PyPI/npm 包发布。
+
+### 目录结构（简要）
+
+```text
+mouse-keepalive/
+├── src/mouse_keepalive/   # Python 包
+├── bin/                   # npm CLI（转发到 python -m mouse_keepalive）
+├── tests/
+├── move_mouse.sh          # 仅本地开发
+└── pyproject.toml
+```
+
+---
+
+## ⚠️ 注意事项
+
+- 使用 **Ctrl + C** 可随时退出  
+- **macOS** 需在「系统设置 → 隐私与安全性 → 辅助功能」中允许终端或 Python  
+- 企业安全策略可能拦截模拟鼠标；若无效请联系管理员或加入白名单  
+
+---
+
+## 📦 发布与版本
+
+用户安装版本以 [PyPI](https://pypi.org/project/mouse-keepalive/) / [npm](https://www.npmjs.com/package/mouse-keepalive) 为准。  
+变更记录见 [CHANGELOG.md](CHANGELOG.md)。仓库使用 [release-please](https://github.com/googleapis/release-please) 管理版本；合并 Release PR 后会发布 `v*` 标签并自动发布到 npm / PyPI。
+
+---
+
+## 📄 许可证
+
+[MIT](LICENSE)

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/mouse_keepalive/__init__.py
+src/mouse_keepalive/__main__.py
+src/mouse_keepalive/move_mouse.py
+src/mouse_keepalive.egg-info/PKG-INFO
+src/mouse_keepalive.egg-info/SOURCES.txt
+src/mouse_keepalive.egg-info/dependency_links.txt
+src/mouse_keepalive.egg-info/entry_points.txt
+src/mouse_keepalive.egg-info/requires.txt
+src/mouse_keepalive.egg-info/top_level.txt
+tests/test_move_mouse.py

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mka = mouse_keepalive.move_mouse:main
+mouse-keepalive = mouse_keepalive.move_mouse:main

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/requires.txt

@@ -0,0 +1,10 @@
+pyautogui>=0.9.54
+
+[dev]
+flake8>=6.0.0
+black>=23.0.0
+pylint>=2.17.0
+mypy>=1.0.0
+pytest>=7.0.0
+pytest-cov>=4.0.0
+yamllint>=1.32.0

mouse_keepalive-1.5.2/src/mouse_keepalive.egg-info/top_level.txt

@@ -0,0 +1 @@
+mouse_keepalive

mouse_keepalive-1.5.2/tests/test_move_mouse.py

@@ -0,0 +1,210 @@
+"""
+Tests for mouse_keepalive.move_mouse module
+"""
+
+import sys
+from pathlib import Path
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+
+src_root = Path(__file__).parent.parent / "src"
+sys.path.insert(0, str(src_root))
+
+from mouse_keepalive.move_mouse import (
+    MouseMover,
+    MouseController,
+    MousePosition,
+    ScreenSize,
+    move_mouse,
+    main,
+)
+
+# Get the module object from sys.modules for patching
+move_mouse_module = sys.modules['mouse_keepalive.move_mouse']
+
+
+class TestMouseMoverCore:
+    def test_calculate_next_position(self):
+        mover = MouseMover()
+        screen = ScreenSize(1920, 1080)
+
+        assert mover.calculate_next_position(MousePosition(100, 200), screen, 0) == (101, 201)
+        assert mover.calculate_next_position(MousePosition(100, 200), screen, 1) == (99, 199)
+
+        x, y = mover.calculate_next_position(MousePosition(0, 0), screen, 0)
+        assert (x, y) == (1, 1)
+
+        x, y = mover.calculate_next_position(MousePosition(1920, 1080), screen, 1)
+        assert (x, y) == (1919, 1079)
+
+    def test_perform_move_calls_controller(self):
+        ctrl = Mock(spec=MouseController)
+        ctrl.get_position.return_value = MousePosition(100, 200)
+        ctrl.get_screen_size.return_value = ScreenSize(1920, 1080)
+
+        mover = MouseMover(controller=ctrl)
+        original, next_count = mover.perform_move(move_count=0)
+
+        assert original == MousePosition(100, 200)
+        assert next_count == 1
+        assert ctrl.move_to.call_count == 2
+
+    def test_run_interval_and_duration(self):
+        ctrl = Mock(spec=MouseController)
+        ctrl.get_position.return_value = MousePosition(100, 200)
+        ctrl.get_screen_size.return_value = ScreenSize(1920, 1080)
+
+        times = [0, 0.1, 1.1, 2.1, 2.1]
+        mock_time = MagicMock(side_effect=times)
+        mock_sleep = MagicMock()
+
+        mover = MouseMover(controller=ctrl, time_func=mock_time, sleep_func=mock_sleep)
+        move_count, elapsed = mover.run(interval=1, duration=2)
+
+        assert move_count >= 2
+        assert elapsed == 2.1
+        assert mock_sleep.call_count >= 2
+
+    def test_run_callbacks_are_called(self):
+        ctrl = Mock(spec=MouseController)
+        ctrl.get_position.return_value = MousePosition(100, 200)
+        ctrl.get_screen_size.return_value = ScreenSize(1920, 1080)
+
+        times = [0, 0.1, 1.1, 1.1]
+        mock_time = MagicMock(side_effect=times)
+        mock_sleep = MagicMock()
+
+        on_start = Mock()
+        on_move = Mock()
+        on_finish = Mock()
+
+        mover = MouseMover(controller=ctrl, time_func=mock_time, sleep_func=mock_sleep)
+        mover.run(
+            interval=1, duration=1,
+            on_start=on_start, on_move=on_move, on_finish=on_finish
+        )
+
+        on_start.assert_called_once()
+        assert on_move.call_count >= 1
+        on_finish.assert_called_once()
+
+
+class TestMoveMouseAPI:
+    @patch.object(move_mouse_module, "MouseController")
+    @patch("time.sleep")
+    @patch("time.time")
+    def test_move_mouse_basic(self, mock_time, mock_sleep, mock_controller_cls):
+        mock_controller = Mock(spec=MouseController)
+        mock_controller.get_position.return_value = MousePosition(100, 200)
+        mock_controller.get_screen_size.return_value = ScreenSize(1920, 1080)
+        mock_controller_cls.return_value = mock_controller
+
+        mock_time.side_effect = [0, 0.1, 1.1, 1.1]
+
+        move_mouse(interval=1, duration=1)
+
+        mock_controller.get_position.assert_called()
+        mock_controller.move_to.assert_called()
+
+    @patch.object(move_mouse_module, "MouseController")
+    @patch("time.sleep")
+    @patch("time.time")
+    def test_move_mouse_bounds(self, mock_time, mock_sleep, mock_controller_cls):
+        mock_controller = Mock(spec=MouseController)
+        mock_controller.get_position.return_value = MousePosition(0, 0)
+        mock_controller.get_screen_size.return_value = ScreenSize(1920, 1080)
+        mock_controller_cls.return_value = mock_controller
+
+        mock_time.side_effect = [0, 0.1, 1.1, 1.1]
+
+        move_mouse(interval=1, duration=1)
+
+        # Check that move_to was called with valid coordinates
+        # First call should be to new position (clamped to bounds), second back to original
+        move_calls = mock_controller.move_to.call_args_list
+        assert len(move_calls) >= 2
+        
+        # First call: move to new position (should be clamped to 1, 1)
+        first_call = move_calls[0]
+        x1, y1 = first_call.args[0], first_call.args[1]
+        assert 1 <= x1 < 1920
+        assert 1 <= y1 < 1080
+        
+        # Second call: move back to original position (0, 0) - this is expected
+        # The bounds check ensures the new position is valid, not the original
+
+    @patch.object(move_mouse_module, "MouseController")
+    @patch("time.sleep", side_effect=KeyboardInterrupt())
+    @patch("time.time")
+    def test_interrupt_does_not_crash(self, mock_time, mock_sleep, mock_controller_cls):
+        mock_controller = Mock(spec=MouseController)
+        mock_controller.get_position.return_value = MousePosition(100, 200)
+        mock_controller.get_screen_size.return_value = ScreenSize(1920, 1080)
+        mock_controller_cls.return_value = mock_controller
+
+        mock_time.side_effect = [0, 0.1, 0.1]
+        move_mouse(interval=1, duration=None)
+
+
+class TestMainCLI:
+    @patch.object(move_mouse_module, "move_mouse")
+    def test_main_with_interval(self, mock_move):
+        import sys
+        orig = sys.argv
+        sys.argv = ["mouse-keepalive", "-i", "30"]
+        try:
+            main()
+        finally:
+            sys.argv = orig
+
+        mock_move.assert_called_once_with(interval=30, duration=None, quiet=False)
+
+    @patch.object(move_mouse_module, "move_mouse")
+    def test_main_with_quiet(self, mock_move):
+        import sys
+        orig = sys.argv
+        sys.argv = ["mouse-keepalive", "-q"]
+        try:
+            main()
+        finally:
+            sys.argv = orig
+
+        mock_move.assert_called_once_with(interval=60, duration=None, quiet=True)
+
+    @patch.object(move_mouse_module, "move_mouse")
+    @patch("builtins.print")
+    def test_main_invalid_params_exit(self, mock_print, mock_move_mouse):
+        """Test that main() handles invalid parameters correctly"""
+        import sys
+        orig_argv = sys.argv
+        
+        for argv in [
+            ["mouse-keepalive", "-i", "0"],
+            ["mouse-keepalive", "-i", "-5"],
+            ["mouse-keepalive", "-d", "0"],
+        ]:
+            sys.argv = argv
+            # sys.exit will be called, which raises SystemExit
+            # pytest may handle this, so we just verify error message was printed
+            try:
+                main()
+            except SystemExit:
+                pass  # Expected - sys.exit raises SystemExit
+            
+            # Verify error message was printed
+            print_messages = []
+            for call in mock_print.call_args_list:
+                if call.args:
+                    print_messages.append(str(call.args[0]))
+            
+            assert any("错误" in msg or "Error" in msg for msg in print_messages), \
+                f"Expected error message for argv {argv}, got: {print_messages}"
+            
+            # move_mouse should not be called for invalid params
+            # (even if sys.exit doesn't work, we've mocked move_mouse to prevent infinite loops)
+            mock_move_mouse.assert_not_called()
+            
+            mock_print.reset_mock()
+            mock_move_mouse.reset_mock()
+        
+        sys.argv = orig_argv