如何在Python中避免睡眠模式，而不需使用额外的应用程序来处理不同的操作系统（Ubuntu、Windows……），但大多数情况下我需要Linux解决方案。
我正在制作一个需要运行较长时间的应用程序。它会使用大约80%的CPU，因此用户只需启动该应用程序并离开键盘即可。因此，我认为我需要类似于系统API或库的东西来锁定睡眠模式。我相信这是存在的。例如，如果您在操作系统上打开任何视频播放器，则您的（PC、笔记本电脑）不会进入睡眠模式，浏览器也是如此。
另外，在Android (WakeLock) 或 Windows (SetThreadExecutionState) 中也有类似的功能。
python -m wakepy [-p]
-p标志将使用演示模式，该模式保持屏幕常亮且解锁。
防止休眠：
from wakepy import keep
with keep.running() as k:
# do stuff that takes long time
防止屏幕保护程序/屏幕锁定(和休眠)：
from wakepy import keep
with keep.presenting() as k:
# do stuff that takes long time
我遇到了类似的情况，一个进程执行时间太长导致Windows进入休眠状态。为了解决这个问题，我编写了一个脚本。
下面这段简单的代码可以解决这个问题。当使用时，它会要求Windows在脚本运行时不要进入睡眠状态。（某些情况下，如电池电量不足时，Windows会忽略您的请求。）
class WindowsInhibitor:
'''Prevent OS sleep/hibernate in windows; code from:
https://github.com/h3llrais3r/Deluge-PreventSuspendPlus/blob/master/preventsuspendplus/core.py
API documentation:
https://msdn.microsoft.com/en-us/library/windows/desktop/aa373208(v=vs.85).aspx'''
ES_CONTINUOUS = 0x80000000
ES_SYSTEM_REQUIRED = 0x00000001
def __init__(self):
pass
def inhibit(self):
import ctypes
print("Preventing Windows from going to sleep")
ctypes.windll.kernel32.SetThreadExecutionState(
WindowsInhibitor.ES_CONTINUOUS | \
WindowsInhibitor.ES_SYSTEM_REQUIRED)
def uninhibit(self):
import ctypes
print("Allowing Windows to go to sleep")
ctypes.windll.kernel32.SetThreadExecutionState(
WindowsInhibitor.ES_CONTINUOUS)
只需运行脚本：
import os
osSleep = None
# in Windows, prevent the OS from sleeping while we run
if os.name == 'nt':
osSleep = WindowsInhibitor()
osSleep.inhibit()
# do slow stuff
if osSleep:
osSleep.uninhibit()
创建了样例TK应用程序以保持Windows处于唤醒状态
import tkinter as tk
import ctypes
import sys
def display_on():
global root
print("Always On")
ctypes.windll.kernel32.SetThreadExecutionState(0x80000002)
root.iconify()
def display_reset():
ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)
sys.exit(0)
root = tk.Tk()
root.geometry("200x60")
root.title("Display App")
frame = tk.Frame(root)
frame.pack()
button = tk.Button(frame,
text="Quit",
fg="red",
command=display_reset)
button.pack(side=tk.LEFT)
slogan = tk.Button(frame,
text="Always ON",
command=display_on)
slogan.pack(side=tk.LEFT)
root.mainloop()
我创建了一个名为stay-awake的包。
PyPi：https://pypi.org/project/stay-awake/
Github：https://github.com/singhsidhukuldeep/stay-awake
Stay-Awake是一个简单的、跨平台的Python包，可以让您的系统保持醒眼状态而不影响工作流程！
不会，在您不进行任何鼠标移动时才会触发此功能！
初衷是提供一种轻量级解决方案，因此目前只有命令行界面！
如果在60秒的时间段内没有移动您的鼠标，此脚本将自动随机移动鼠标1到4个像素，不会有任何鼠标位移！如果您正在工作，它会完全没有影响！
pip3 install stay-awake
python3 -m stay-awake
您还可以设置自定义超时时间 例如：5分钟（默认为1分钟）
python3 -m stay-awake 5
根据我在互联网上发现的多种方法，我制作了以下模块。特别感谢@mishsx提供的Windows解决方案。
使用它非常简单。您可以选择使用standby_lock装饰器方法或通过StandbyLock上下文管理器：
## decorator
@standby_lock
def foo(*args, **kwargs):
# do something lazy here...
pass
## context manager
with StandbyLock():
# ...or do something lazy here instead
pass
当执行 foo 时，您的系统将保持唤醒状态。
注意：仍有一些注意事项，因为Linux可能需要sudo特权，而OS X（Darwin）尚未经过测试。
from functools import wraps
import platform
class MetaStandbyLock(type):
"""
"""
SYSTEM = platform.system()
def __new__(cls, name: str, bases: tuple, attrs: dict) -> type:
if not ('inhibit' in attrs and 'release' in attrs):
raise TypeError("Missing implementations for classmethods 'inhibit(cls)' and 'release(cls)'.")
else:
if name == 'StandbyLock':
cls._superclass = super().__new__(cls, name, bases, attrs)
return cls._superclass
if cls.SYSTEM.upper() in name.upper():
if not hasattr(cls, '_superclass'):
raise ValueError("Class 'StandbyLock' must be implemented.")
cls._superclass._subclass = super().__new__(cls, name, bases, attrs)
return cls._superclass._subclass
else:
return super().__new__(cls, name, bases, attrs)
class StandbyLock(metaclass=MetaStandbyLock):
"""
"""
_subclass = None
@classmethod
def inhibit(cls):
if cls._subclass is None:
raise OSError(f"There is no 'StandbyLock' implementation for OS '{platform.system()}'.")
else:
return cls._subclass.inhibit()
@classmethod
def release(cls):
if cls._subclass is None:
raise OSError(f"There is no 'StandbyLock' implementation for OS '{platform.system()}'.")
else:
return cls._subclass.release()
def __enter__(self, *args, **kwargs):
self.inhibit()
return self
def __exit__(self, *args, **kwargs):
self.release()
class WindowsStandbyLock(StandbyLock):
"""
"""
ES_CONTINUOUS = 0x80000000
ES_SYSTEM_REQUIRED = 0x00000001
INHIBIT = ES_CONTINUOUS | ES_SYSTEM_REQUIRED
RELEASE = ES_CONTINUOUS
@classmethod
def inhibit(cls):
import ctypes
ctypes.windll.kernel32.SetThreadExecutionState(cls.INHIBIT)
@classmethod
def release(cls):
import ctypes
ctypes.windll.kernel32.SetThreadExecutionState(cls.RELEASE)
class LinuxStandbyLock(metaclass=MetaStandbyLock):
"""
"""
COMMAND = 'systemctl'
ARGS = ['sleep.target', 'suspend.target', 'hibernate.target', 'hybrid-sleep.target']
@classmethod
def inhibit(cls):
import subprocess
subprocess.run([cls.COMMAND, 'mask', *cls.ARGS])
@classmethod
def release(cls):
import subprocess
subprocess.run([cls.COMMAND, 'unmask', *cls.ARGS])
class DarwinStandbyLock(metaclass=MetaStandbyLock):
"""
"""
COMMAND = 'caffeinate'
BREAK = b'\003'
_process = None
@classmethod
def inhibit(cls):
from subprocess import Popen, PIPE
cls._process = Popen([cls.COMMAND], stdin=PIPE, stdout=PIPE)
@classmethod
def release(cls):
cls._process.stdin.write(cls.BREAK)
cls._process.stdin.flush()
cls._process.stdin.close()
cls._process.wait()
def standby_lock(callback):
""" standby_lock(callable) -> callable
This decorator guarantees that the system will not enter standby mode while 'callable' is running.
"""
@wraps(callback)
def new_callback(*args, **kwargs):
with StandbyLock():
return callback(*args, **kwargs)
return new_callback
这段代码用于每隔n分钟移动鼠标光标以保持系统不休眠。
首先需要安装Python的pyautogui库。
运行以下代码：
import pyautogui
import time
import sys
from datetime import datetime
pyautogui.FAILSAFE = False
numMin = None
if ((len(sys.argv)<2) or sys.argv[1].isalpha() or int(sys.argv[1])<1):
numMin = 2 # move cursor after numMin minutes
else:
numMin = int(sys.argv[1])
while(True):
x=0
while(x<numMin):
time.sleep(60)
x+=1
for i in range(0,50):
pyautogui.moveTo(i*6+50,i*4)
pyautogui.moveTo(1,1)
for i in range(0,3):
pyautogui.press("shift")
print("Movement made at {}".format(datetime.now().time()))
nohup ./keepawake.py -c 13 -r > /dev/null 2>&1 &
要作为后台服务运行，并将15分钟（900秒）设置为用户活动空闲时间，以确定用户是否处于空闲状态：
nohup ./keepawake.py -u 900 -r > /dev/null 2>&1 &
要作为后台服务运行并将最小网络流量设置为5KB（5120字节）：
nohup ./keepawake.py -s 5120 -r > /dev/null 2>&1 &
要将其作为后台服务运行并在1小时后设置计划休眠/挂起（仅当确定用户活动、CPU和网络流量均为空闲时才设置此值）：
nohup ./keepawake.py -w 3600 -r > /dev/null 2>&1 &
nohup ./keepawake.py -s 5120 -c 13 -u 900 -w 3600 -l /home/$USER/sleep/log/Keep.Awake/ -v Detail -r > /dev/null 2>&1 &
import subprocess
from time import sleep
def main():
while(True):
p = subprocess.Popen("shutdown /a", stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
res = p.communicate()
p.kill()
sleep(30) # sleep 30 sec.
if __name__ == "__main__":
main()
Python3
安装库
pip install pywin32
将下面的代码保存为alive.pyw文件
from ctypes import windll, wintypes, byref, c_uint, sizeof, Structure
import tkinter as tk
import ctypes
import sys
import threading
import time
import win32api
import win32con
stop_threads = True
SET_IDLE_TIME = 40 #in seconds
class LASTINPUTINFO(Structure):
_fields_ = [
('cbSize', c_uint),
('dwTime', c_uint),
]
def get_idle_duration():
lastInputInfo = LASTINPUTINFO()
lastInputInfo.cbSize = sizeof(lastInputInfo)
windll.user32.GetLastInputInfo(byref(lastInputInfo))
millis = windll.kernel32.GetTickCount() - lastInputInfo.dwTime
return millis / 1000.0
def press_key_2():
global stop_threads
while True:
if not stop_threads:
break
idle_time = get_idle_duration() #seconds
time.sleep(0.1)
if idle_time < SET_IDLE_TIME:
continue
print("in ideal state pressing cltr")
win32api.keybd_event(ord('x'), 0, win32con.KEYEVENTF_EXTENDEDKEY, 0)
#---------------- Monitor threads ------------------------------
t1 = threading.Thread(target=press_key_2, name='t1')
t1.daemon = True
#----------------- TK functions ----------------------
def display_on():
global tk, t1, stop_threads
stop_threads = True
print("Always On")
ctypes.windll.kernel32.SetThreadExecutionState(0x80000002)
root.iconify()
t1.start()
# t2.start()
def display_reset():
print("quit pressed")
global stop_threads
stop_threads = False
ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)
sys.exit(0)
root = tk.Tk()
root.geometry("200x110")
root.title("Display App")
frame = tk.Frame(root)
frame.pack()
var = tk.StringVar()
label = tk.Label(frame, textvariable = var)#, bd = 5, justify = tk.RIGHT, padx = 10, pady = 10)
var.set("")
button = tk.Button(frame,
text="Quit",
fg="red",
command=display_reset)
slogan = tk.Button(frame,
text="Always ON",
command=display_on)
label.pack(side=tk.BOTTOM,padx=0, pady=0)
slogan.pack(side=tk.LEFT,padx=15, pady=20)
button.pack(side=tk.LEFT,padx=15, pady=20)
root.mainloop()
ctypes.windll.kernel32.SetThreadExecutionState(0x80000000)
你也可以使用Caffeine+，它是一个小巧的托盘应用程序，可以让系统保持唤醒状态，而不需要模拟键盘事件或干扰用户界面。https://enemydevelopment.com/software/caffeine
tkinter制作的吗？您需要提供详细信息以便其他人帮助您。 - mishsxWakeLock或SetThreadExecutionState或其他依赖于其运行的操作系统的内容。 - zvonestay-awake的软件包PyPi: https://pypi.org/project/stay-awake/Github: https://github.com/singhsidhukuldeep/stay-awake 更多细节请查看答案 - Kuldeep Singh Sidhu