Gamelimiter - Limit your Gaming

[deets]

edit_processes sieht grausam aus. Dir ist "".split bekannt? Generell sieht das *sehr* danach aus, das du string-manipulation ueben solltest.

[cofi]

habs mit irgendwo rauskopiert ich ändere es eben.

Nein, stopp. Erst nachdenken.

Auch wenn ich ebenfalls UTF-8 bevorzuge, so muss das Coding Cookie mit der _tatsaechlichen_ Kodierung zusammenpassen und nicht einer Wunschkodierung.
Wenn ich richtig sehe, nutzt du Python 3, dort ist UTF-8 die Default Kodierung, du kannst es also auch weglassen.

[Scriptinggamer]

Danke für euer Interesse und eure Tipps,
Kann ichs trotzdem da lassen?
oder sollte ich die Codingzeile entfernen?
Nachdenken hätte nichts gebracht, ich wusste garnicht was für ein Coding standart ist.
Ich werd mir mal ansehen was ich so an der Stringmanipulation verbessern kann.
Gruß

[cofi]

Nachdenken hätte nichts gebracht, ich wusste garnicht was für ein Coding standart ist.

Du musst wissen wie die Datei kodiert ist, sonst ist jedes Cookie Kaese, das hat mit den _Python_ Defaults nichts zu tun, sondern einzig mit dem Editor den du verwendest.

[Leonidas]

Naja, das Programm tut unter Linux schon mal nicht, weil überall Windows-spezifischer Kram verwendet wird. Wird die anzahl der potentiellen Tester ein gutes Stück einschränken.

[Scriptinggamer]

Für linux war es auch garnicht gedacht, ich möchte es ja dann sowieso in ne exe packen, aber wenn es sonst nichts mehr auszusetzten gibt, kann ich die version die ich dann als python script veröffentliche, noch für Linux optimieren. Wenn ich es unter Linux ausführe sehe ich ja wo fehler aufkommen und kann sie dann googeln...
Aber was sagst du zu der verwendung von time.sleep() wärend dem tkinter nicht aktiv ist?
Sollte ich das immernoch irgendwie ersetzen?

An der stelle wo ich die spaces raussammle, werde ich dann mal .split() verwenden und dann alle "wörter" mit einem space in der mitte zusammenfügen bis ein Komma kommt (es gibt ja Prozesse aus mehreren Wörtern).
Gruß

[deets]

string.join?

[Scriptinggamer]

Naja es geht an der Stelle darum, einen String mit durch kommas getrennten Prozessen ("beispiel1.exe, beispiel zwei.exe"), unterteilt in eine Liste zu stecken.
Gruß

[deets]

Code: Alles auswählen

pliste = "Prozess1, Prozess2".split(",")

[Scriptinggamer]

Ja, is mir dann auch eingefallen, zusammen mit dem entspacen:

Code: Alles auswählen

string = "process.exe , hallo.exe,  zwei wörter.exe     "
processlist = list()
for process in string.split(","):
    while True:
        if process.startswith(" "):
            process = process[1:]
        elif process.endswith(" "):
            process = process[:-1]
        else:
            break
    processlist.append(process)
print(processlist)

hab ich auf dem ipod geschrieben, also kann ich es im programm erst später fixen
Danke
Gruß

[cofi]

Du hast da aber ganz toll `str.strip` neu implementiert.

Code: Alles auswählen

In [1]: string = "process.exe , hallo.exe,  zwei wörter.exe     "

In [2]: processes = [p.strip() for p in string.split(",")]

In [3]: processes
Out[3]: ['process.exe', 'hallo.exe', 'zwei w\xc3\xb6rter.exe']

Wenn du etwas mit Basistypen anstellen willst, schau dir erstmal die Dokumentation an: http://docs.python.org/library/stdtypes ... ng-methods

(Wobei das eigentlich immer gilt ..)

[Scriptinggamer]

hijahaha, ich bin eben ein kleiner Implementator
alles klar, hab das und noch einiges anderes verbessert. Man kann jetzt nach dem Task-check die Tasks auswählen die man der Liste hinzufügen möchte und sie dann hinzufügen.

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-

#Module importieren
import tkinter as tk
from tkinter import messagebox
import time
import pickle
import winsound
import subprocess

#Klasse definieren
class App:
    #Hauptfenster initialisieren
    def __init__(self, master):
        self.master = master
        self.master.title("Gamelimiter")
        self.master.tk.call('wm', 'iconbitmap', self.master._w, '-default', 'glicon.ico')
        self.add_widgets()

    #Widgets hinzufügen
    def add_widgets(self):
        self.radio_check = tk.IntVar()
        self.block_check = tk.IntVar()
       
        self.radio_check.set(1)
        self.block_check.set(0)

        #Widgets initialisieren
        head_label = tk.Label(self.master, text = "Herzlich willkommen!\nWie lange möchtest du spielen?")
        self.time_entry_h = tk.Entry(self.master, width = 4)
        seperator_label = tk.Label(self.master, text = ":")
        self.time_entry_m = tk.Entry(self.master, width = 4)
        time_radio_1 = tk.Radiobutton(self.master, text = "Zeit herunterzählen", variable = self.radio_check, value = 1)
        time_radio_2 = tk.Radiobutton(self.master, text = "Als Uhrzeit verwenden", variable = self.radio_check, value = 2)
        start_button = tk.Button(self.master, text = "Starten", command = self.countdown)
        edit_processes_button = tk.Button(self.master, text = "Prozesse verwalten", command = self.edit_processes)
        block_check_button = tk.Checkbutton(self.master, text = "Dann eine Stunde blocken", variable = self.block_check)

        self.time_entry_h.insert(10, "h")
        self.time_entry_m.insert(10, "m")

        #Widgets positionieren
        head_label.grid(row = 0, column = 0, columnspan = 3)
        self.time_entry_h.grid(row = 1, column = 0, sticky = "e")
        seperator_label.grid(row = 1, column = 1)
        self.time_entry_m.grid(row = 1, column = 2, sticky = "w")
        time_radio_1.grid(row = 2, column = 0)
        time_radio_2.grid(row = 2, column = 2)
        start_button.grid(row = 3, column = 0, columnspan = 3, sticky = "w,e")
        edit_processes_button.grid(row = 4, column = 2, sticky = "e")
        block_check_button.grid(row = 4, column = 0, columnspan = 3, sticky = "w")

    #Zeit einlesen, verarbeiten und herunterzählen
    def countdown(self):
        #Zeit zum herunterzählen
        if self.radio_check.get() == 1:
            if self.time_entry_h.get().isdigit() and 0 <= int(self.time_entry_h.get()) <= 60:
                play_time = int(self.time_entry_h.get()) * 3600
            else:
                play_time = 0
            if self.time_entry_m.get().isdigit() and 0 <= int(self.time_entry_m.get()) <= 60:
                play_time += int(self.time_entry_m.get()) * 60
        #Zeit bis zur Uhrzeit
        else:
            if self.time_entry_h.get().isdigit() and 0 <= int(self.time_entry_h.get()) <= 60:
                time_end_m = int(self.time_entry_h.get()) * 60
                hour_isset = True
            else:
                time_end_m = int(time.strftime("%H")) * 60
                hour_isset = False
            if self.time_entry_m.get().isdigit() and 0 <= int(self.time_entry_m.get()) <= 60:
                time_end_m += int(self.time_entry_m.get())
            elif not hour_isset:
                time_end_m += int(time.strftime("%M"))
               
           
            time_now_m = int(time.strftime("%H")) * 60 + int(time.strftime("%M"))
            if time_now_m <= time_end_m:
                play_time = (time_end_m - time_now_m)*60
            else:
                play_time = (time_end_m - time_now_m + 1440)*60

        #Zählen starten
        self.master.destroy()
        if play_time != 0:
            if play_time <= 300:
                time.sleep(play_time -11)
            else:
                time.sleep(play_time - 300)
                subprocess.call("start warnung.exe", shell = True)
                time.sleep(289)
            winsound.PlaySound("beep.wav", winsound.SND_FILENAME)
        self.kill_tasks()

    #Prozesse überprüfen und beenden
    def kill_tasks(self):
        #Überprüfen des Befehls
        def system_test():
            if subprocess.call(["taskkill", "/IM", "testprozessname"], shell = True) == 128:
                return("taskkill")
            else:
                return("tskill")
           
        #Prozesse aus Datei einlesen
        file_processes = open("prozesse.data", "rb")
        processes = pickle.load(file_processes)
        file_processes.close()
       
        #Rückmeldung vorbereiten
        processes_closed = []
        processes_failed = []
        processes_opened = str(subprocess.check_output("tasklist", shell = True), encoding='utf8')
       
        #Prozesse versuchen zu beenden
        self.befehl = system_test()
        for process in processes:
            if process in processes_opened:
                if subprocess.call([self.befehl, "/F", "/IM", process, "/T"], shell = True) != 1:
                    processes_closed.append(process)
                else:
                    processes_failed.append(process)

        #Root erstellen
        endroot = tk.Tk()
        endroot.title("Beenden")
       
        head_label = tk.Label(text = "Das Programm ist fertig!")
        end_button = tk.Button(text = "Beenden", command = endroot.destroy)

        head_label.grid(row = 0)
        end_button.grid(row = 1, sticky = "w,e")
       
        #Rückmeldung geben
        if len(processes) == 0:
            messagebox.showwarning(title = "Keine Prozesse", message = "Du hast noch keine Prozesse gespeichert!")
        elif len(processes_closed) > 0 and len(processes_failed) == 0:
            messagebox.showwarning(title = "Prozesse beendet",
                                   message = "Folgende Prozesse wurden beendet:\n" + "\n".join(processes_closed))
        elif len(processes_closed) > 0:
            messagebox.showwarning(title = "Prozesse beendet",
                                   message = "Folgende Prozesse wurden beendet:\n" + "\n".join(processes_closed) + "\nFolgende Prozesse konnten nicht Beendet werden:\n" + "\n".join(processes_failed))
        elif len(processes_failed) > 0:
            messagebox.showwarning(title = "Beenden fehlgeschlagen",
                                   message = "Für folgende Prozesse reichen die Rechte nicht aus:\n(Dies lässt sich beheben indem das Programm\nals Administrator ausgeführt wird)\n" + "\n".join(processes_failed))
        else:
            messagebox.showwarning(title = "Keinen Prozess beendet",
                                   message = "Keiner der gespeicherten Prozesse ist geöffnet!")
        #Mainloop starten
        endroot.mainloop()
        if self.block_check.get() and len(processes) != 0:
            self.block()

    def edit_processes(self):
        #Prozesse separieren, despacen und in die Datei schreiben
        def safe_processes():
            process_list = [process.strip() for process in process_entry.get().split(",") if len(process.strip()) > 4 and "." in process]
            process_file = open("prozesse.data", "wb")
            pickle.dump(process_list, process_file)
            process_file.close()
            messagebox.showwarning(title = "Speichern erfolgreich!", message = "Erfolgreich gespeichert!")
            edit_toplevel.destroy()

        #Tasks-einlesen-Dialog
        def get_tasks():
            #Tasks vergleichen und ausgeben
            def compare_tasks():
                def add_checked_tasks():
                    add_list = [added_tasks[i] for i in range(len(check_variables)) if check_variables[i].get()]
                    added_tasks_toplevel.destroy()
                    if process_entry.get() == "":
                        process_entry.insert("end", ", ".join(add_list))
                    elif process_entry.get().endswith(",") or process_entry.get().endswith(", "):
                        process_entry.insert("end", ", ".join(add_list))
                    else:
                        process_entry.insert("end", ", " + ", ".join(add_list))
                    
                tasks_after = str(subprocess.check_output("tasklist", shell = True), encoding='utf8').splitlines()[4:]
                added_tasks = []
                for task_a in tasks_after:
                    in_list = False
                    for task_b in tasks_before:
                        if task_a[:task_a.find("    ")] == task_b[:task_b.find("    ")]:
                            in_list = True
                    if not in_list:
                        added_tasks.append(task_a[:task_a.find("    ")])
                if len(added_tasks) == 0:
                    messagebox.showwarning(title = "Tasks", message = "Es sind keine Tasks hinzugekommen!")
                else:
                    added_tasks_toplevel = tk.Toplevel(edit_toplevel)
                    added_tasks_toplevel.title("Tasks")
                    tasks_head_label = tk.Label(added_tasks_toplevel, text = "Folgende Tasks wurden geöffnet:")
                    tasks_head_label.grid(row = 0, column = 0, columnspan = 2)
                    check_variables = list()
                    for i in range(len(added_tasks)):
                        check_variables.append(tk.IntVar())
                        tk.Label(added_tasks_toplevel, text = added_tasks[i]).grid(row = i+1, column = 0)
                        tk.Checkbutton(added_tasks_toplevel, variable = check_variables[i]).grid(row = i+1, column = 2)
                    add_tasks_button = tk.Button(added_tasks_toplevel, text = "Hinzufügen", command = add_checked_tasks)
                    add_tasks_button.grid(row = len(added_tasks)+1, column = 0)
                    break_added_tasks_button = tk.Button(added_tasks_toplevel, text = "Abbrechen", command = added_tasks_toplevel.destroy)
                    break_added_tasks_button.grid(row = len(added_tasks)+1, column = 1)

                get_tasks_toplevel.destroy()
           
            #Offene Prozesse einlesen
            tasks_before = str(subprocess.check_output("tasklist", shell = True), encoding='utf8').splitlines()[4:]

            #Toplevel initialisieren
            get_tasks_toplevel = tk.Toplevel(edit_toplevel)
            get_tasks_toplevel.title("Tasks einlesen")

            #Widgets initialisieren
            head_label = tk.Label(get_tasks_toplevel, text = "Starte das Spiel und drücke den Button!")
            get_tasks_button = tk.Button(get_tasks_toplevel, text = "Überprüfen", command = compare_tasks)

            head_label.grid(row = 0)
            get_tasks_button.grid(row = 1, sticky = "w,e")
       
        #Prozesse importieren
        process_file = open("prozesse.data")
        if process_file.read() == "":
            text = ""
        else:
            process_file = open("prozesse.data", "rb")
            text = ", ".join(pickle.load(process_file))
        process_file.close()
       
        #Toplevel initialisieren
        edit_toplevel = tk.Toplevel()
        edit_toplevel.title("Prozesse verwalten")

        #Widgets initialisieren
        head_label = tk.Label(edit_toplevel, text = "Gib hier die Prozesse deiner Spiele ein:")
        process_entry = tk.Entry(edit_toplevel)
        safe_button = tk.Button(edit_toplevel, text = "Speichern", command = safe_processes)
        break_button = tk.Button(edit_toplevel, text = "Abbrechen", command = edit_toplevel.destroy)
        get_button = tk.Button(edit_toplevel, text = "Tasks einlesen", command = get_tasks)

        process_entry.insert(10, text)

        #Widgets positionieren
        head_label.grid(row = 0, column = 0, columnspan = 3)
        process_entry.grid(row = 1, column = 0, columnspan = 3, sticky = "w,e")
        safe_button.grid(row = 2, column = 0)
        break_button.grid(row = 2, column = 1)
        get_button.grid(row = 2, column = 2)

    def block(self):
        #Prozesse aus Datei importieren
        file_processes = open("prozesse.data", "rb")
        processes = pickle.load(file_processes)
        file_processes.close()        

        #1 Stunde lang jede minute prüfen
        i = 60
        while i > 0:
            i -= 1
            time.sleep(60)
            processes_opened = str(subprocess.check_output("tasklist", shell = True), encoding='utf8')
            for process in processes:
                if process in processes_opened:
                    subprocess.call([self.befehl, "/F", "/IM", process, "/T"], shell = True)

def main():
    root = tk.Tk()
    app = App(root)
    root.mainloop()

if __name__ == "__main__":
    main()

Nur her mit weiteren Verbesserungsideen.
Gruß

[BlackJack]

@Scriptinggamer: Ich würde die externen Aufrufe zur Prozesssteuerung durch das psutil-Modul ersetzen.

Ich glaube zu Kommentaren wie ``#Module importieren`` oder ``#Klasse definieren`` hatte ich schon mal an anderer Stelle etwas gesagt. Wenn es nicht einen deutlichen Mehrwert zum bereits vorhandenen Quelltext bietet, dann weg damit.

Diese ganzen ``int(time.strftime("%M"))`` um einzelne Teile der aktuellen Zeit zu bekommen sind unnötig kompliziert. Mit `time.localtime()` bekommt man zum Beispiel ein Objekt bei dem die Bestandteile direkt als Zahlen abfragen kann. Noch besser wäre es aber die Datentypen aus dem `datetime`-Modul zu verwenden, denn mit denen kann man sogar Rechnen, also zum Beispiel Zeiten voneinander abziehen um die `play_time` mit einem einfachen ``-`` zu berechnen.

``return`` ist keine Funktion, also sollte man die Anweisung nicht auf eine Weise mit unnötigen Klammern versehen, dass es so aussieht als wenn es eine Funktion wäre.

Dateien sollte man wenn möglich mit der ``with``-Anweisung öffnen.

Bei den `subprocess`-Aufrufen macht es wenig Sinn das erste Argument als Liste zu übergeben, aber gleichzeitig ``shell=True`` anzugeben. Wobei die Frage ist, warum überhaupt eine Shell dazwischen geschaltet werden muss.

Speichern heisst auf Englisch „save” und nicht „safe”.

`showwarning()` um erfolgreiches Speichern zu melden erscheint mir semantisch nicht richtig.

Die `edit_processes()`-Methode macht deutlich zu viel und ist zu komplex. Da sind ``def``-Anweisungen vier Ebenen tief verschachtelt. Selbst in einer funktionalen Sprache wie Haskell würde ich das nicht in einer Funktion machen — das wird schnell unübersichtlich. Und keine der lokalen und verschachtelten „Funktionen” bekommt Argumente oder gibt etwas zurück. Die operieren alle auf irgendwelchen Daten deren Herkunft man erst mühsam suchen muss auf welcher Ebene sie überhaupt eingeführt werden. Vom Objekt auf dem die Methode definiert ist, wird übrigens überhaupt nichts verwendet. Damit ist das keine richtige Methode und gehört entweder nicht in die Klasse oder zumindest mit einem `staticmethod`-Dekorator als Funktion gekennzeichnet.

Beim Test ob neue Tasks hinzugekommen sind habe ich so ein bisschen das Gefühl Du arbeitest auf einer bestimmten Repräsentation von Daten für den Benutzer statt auf Datenstrukturen die den Operationen angemessen sind. Die Operationen die da etwas komisch auf Listen, anscheinend mit einem besonderen Elementen das aus vier Leerzeichen besteht, durchgeführt werden, sehen nach Mengenoperationen aus, die man konsequenterweise besser mit dem dafür vorgesehenen Datentyp `set()` realisieren sollte.

``for i in range(len(sequence))`` um dann mit `i` auf Elemente von `sequence` zuzugreifen ist ein klassisches Anti-Pattern in Python. Wenn man *zusätzlich* zu den Elementen einen Index benötigt, sollte man die `enumerate()`-Funktion verwenden.

Beim Laden der ``prozesse.data`` in `edit_processes()` wird die Datei zweimal geöffnet aber nur einmal wieder geschlossen. Das könnte man mit ``with`` vermeiden. Wobei mir das erste Einlesen nicht sinnvoll erscheint. Wenn Du immer per `pickle` Daten in diese Datei schreibst, kann sie niemals einfach nur leer sein. Den Fall braucht man also nicht prüfen. Andererseits könnte man das auch per Ausnahmebehandlung abarbeiten wenn das Programm auch auf einen fehlerhaften Dateiinhalt entsprechend reagieren soll.

In `block()` werden wieder Mengenoperationen mit Listen und damit einem deutlich schlechterem Laufzeitverhalten nachimplementiert. Und die ``while``-Schleife sollte eine ``for``-Schleife sein.

Der Programmfluss ist IMHO etwas unübersichtlich. Wenn in der `main()` ein `Tk`-Exemplar erstellt und die `mainloop()` aufgerufen wird, erwarte ich nicht dass innerhalb der `App`-Klasse nach dem Ende der `mainloop()` irgend wo *noch einmal* ein `Tk`-Exemplar erstellt wird und noch eine `mainloop()` gestartet wird.

Insgesamt könnte man auch Geschäftslogik und GUI voneinenander Trennen. Dann kommt man vielleicht auch nicht so leicht in Versuchung auf Daten zu operieren die eigentlich zum Anzeigen gedacht sind.

Zur Form: Relativ viele Zeilen sind länger als 80 Zeichen.

[Scriptinggamer]

DANKE!
Das ist ein Großer Informationshaufen, der viel Arbeit für mich bedeuted, aber er wird das Programm sicherlich stark verbessern.
Ich danke dir und allen anderen, dass ihr euch so intensiev mit meinem Problem beschäfftigt
Gruß

[Scriptinggamer]

Guten!
Die neue Version ist in Arbeit, ich hab da eine Frage:
Wie stelle ich es an, dass ein Toplevel das durch einen Button aufgerufen wird, sich nur öffnet wenn es nicht schon offen ist?
Muss ich das manuell programmieren oder gibts da was einfacheres?
Gruß

[deets]

Sowas musst du manuell programmieren, und es ist ja nun auch trivialst.

[Scriptinggamer]

Und kann man das root fenster wären dem blockieren? Also das man darauf nichts mehr klicken kann?
Gruß

[Scriptinggamer]

Hallo, ich mal wieder,
Nachdem ich mal wieder zu dumm für git war, hab ichs letztendlich doch geschafft und das Script ist jetzt verfügbar, ich hab versucht alles schön zu Ordnen und Aufzubauen und den Editor Verbessert. Da ich aber komplet von Vorne angefangen hab, kann ich nicht so genau sagen was ich wo geändert hab, schauts euch einfach an

[Dav1d]

Ich habe das ganze mal überflogen, alles was mir aufgefallen ist (Logik habe ich mal außen vorgelassen):

Zeile 14: du meintest 79 Zeichen, oder .

Zeile 156:

Code: Alles auswählen

        if add_mode.get() == 0:
            self.add_task_auto()
        elif add_mode.get() == 1:
            self.add_task_from_list()
        elif add_mode.get() == 2:
            self.add_task_manual()

Sowas kann man schön mit einem Dictionary machen (das lässt sich dann auch einfacher erweitern):

Code: Alles auswählen

dispatch = {0 : self.add_task_auto, 1 : self.add_task_from_list, 2 : self.add_task_manual}
dispatch[add_mode.get()]()

In diesem Fall könnte man auch eine Liste verwenden:

Code: Alles auswählen

dispatch = [self.add_task_auto, self.add_task_from_list, self.add_task_manual]
dispatch[add_mode.get()]()

Zeile 336:

Code: Alles auswählen

def system_test():
    try:
        subprocess.call("taskkill /?", shell = True)
    except:
        return "tskill"
    else:
        return "taskkill"

Das is garnicht schön und funktioniert auch nicht (unter Linux existiert weder tskill noch taskkill), des Weiteren fängst du *jeden* Fehler ab, auch z.B. wenn der Nutzer mit `Strg+C` unterbrechen will. Fange nur die Fehler ab, die du auch abfangen willst, in diesem Fall `subprocess.CalledProcessError`.

Zeile 343: Die Funktion verstehe ich nicht, die wird immer einen Fehler werfen da es `task.exe` nicht gibt → NameError.

[Scriptinggamer]

Hey, danke für die Tipps,

also das mit der liste is ne gute idee, ich bin ja noch nicht so erfahren, in php würde man es ja mit case machen

Es sollen also maximal 79 Zeichen sein? Och mist, muss ich wohl noch ein bisschen nacharbeiten...

beim Systemtest war ich zu faul um den Error zu suchen, ja, das sollte ich wohl auch ersetzen

und zum Schluss: doch, die Funktion tut was sie soll, der Funktion wird ein Argument (task) mitgegeben, task steht für einen Prozess aus dem psutil Modul und hat eine Instanz-Variable (exe). Die Funktion testet, ob das Programm die Rechte dazu hatt auf diese exe-Variable zuzugreifen, ich weiß nicht ob es da ne bessere Methode gibt, aber so funktioniert es zumindest.

Gruß