Das deutsche Python-Forum

Code: Alles auswählen

def check_existing_instance(instance):
    import psutil
    from datetime import datetime, timedelta
    check_time = datetime.now() - timedelta(seconds = 10)
    stamped = check_time.timestamp()
    
    for p in psutil.process_iter():
        
        if "python" in p.name():
            
           if instance in p.cmdline()[1] and stamped > p.create_time():
                return p
    return None

Code: Alles auswählen

import psutil
import os
import sys

def check_existing_instance(instance):
    own_pid = os.getpid()
    return any(
        p.exe() == sys.executable and instance in p.cmdline()[1] and p.pid != own_pid
        for p in psutil.process_iter()
    )

Code: Alles auswählen

from psutil import process_iter

# bei mir knallt es erst bei PID 2
list(p.exe() for p in process_iter())

Code: Alles auswählen

import time
import sys
import subprocess

from psutil import Process, process_iter


def check_existing_instance():
    self_proc = Process()
    self_cmdline = self_proc.cmdline()
    self_pid = self_proc.pid

    for proc in process_iter():
        if proc.cmdline() == self_cmdline and proc.pid != self_pid:
            return True

    return False



if check_existing_instance():
    raise SystemExit("Es läuft eine zweite Instanz. Abbruch")
else:
    print("Die einzige Instanz")


print("Starte nun das gleiche Programm nochmal, was dann die Meldung auslösen sollte")
cmdline = Process().cmdline()
print(" ".join(cmdline))
subprocess.run(cmdline)


time.sleep(10)
print("Beende erste Instanz")

Code: Alles auswählen

import fcntl

def main():
    try:
        with open(__file__ ) as ownfile:
            fcntl.flock(ownfile.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
            input('simulate the program running. (enter to exit)')
    except BlockingIOError:
        print('Other instance is running')
        
if __name__ == '__main__':
    main()

Code: Alles auswählen

#archivfenster.py
import tkinter as tk
import tkinter.messagebox as messagebox
from archiv import *

def main():
    if check_existing_instance("archiv"):
        messagebox.showerror(title="bereits geöffnet", message="Das Fenster ist bereits geöffnet.")
        return


    root = tk.Tk()
    root.title("GUI_Archiv")
    Archiv(root)
    root.mainloop()

if __name__ == "__main__":
    main()    

Code: Alles auswählen

#archiv.py
import tkinter as tk
from psutil import Process, process_iter
import os

class Archiv:
    def __init__(self, parent:tk.Tk):
        self.window = parent
        tk.Label(self.window, text="Archivinhalt etc").pack()

def check_existing_instance(instance):
    self_proc = Process()
    self_cmdline = self_proc.cmdline()
    self_pid = self_proc.pid

    for proc in process_iter():
        if "python" in proc.name():
            if proc.cmdline() == self_cmdline and proc.pid != self_pid:
                return True

    return False

Code: Alles auswählen

#berechnungsfenster.py 
import tkinter as tk
import tkinter.messagebox as messagebox
from archiv import *
import subprocess
import sys

class Berechnungsfenster:
    def __init__(self, parent:tk.Tk):
        self.window = parent
        tk.Label(self.window, text="Berechnungskram etc").pack()
        tk.Button(self.window, text="Archiv öffnen", command=self.archiv).pack()

    def archiv(self):
        # #1
        # if check_existing_instance("GUI_Archiv"):
        #     messagebox.showerror(title="bereits geöffnet", message="Das Fenster ist bereits geöffnet.")
        #     return

        # root=tk.Toplevel()
        # root.title("GUI_Archiv")
        # Archiv(root)
        # root.mainloop()

        #2
        if check_existing_instance("archiv"):
            messagebox.showerror(title="bereits geöffnet", message="Das Fenster ist bereits geöffnet.")
            return

        subprocess.Popen([sys.executable, "archivfenster.py"], shell=False)

if __name__ == "__main__":
    root = tk.Tk()
    root.title("GUI_Berechnung")
    Berechnungsfenster(root)
    root.mainloop()

Code: Alles auswählen

def beende_anwendung(lock_file):
    if Path.exists(lock_file):
        Path.unlink(lock_file)
        exit()   
        
def pruefe_lock_file(lock_file):
    if Path.exists(lock_file):
        print("Anwendung schon geöffnet")      
        exit()
    else:
        with open (lock_file, 'w') as file:
            print("starte Anwendung")

def meine_anwendung():
    lock_file = Path('/var/tmp/meine_anwendung_lock')
    pruefe_lock_file(lock_file)
    root = tk.Tk()
    tk.Button(root, text='Beenden', command=partial(beende_anwendung,
                                                    lock_file)).pack()    
    root.mainloop()    
    
if __name__ == "__main__":
    meine_anwendung()