Das deutsche Python-Forum

Code: Alles auswählen

# Überprüfe ob ID aus pidpath aktuell ist
    id_ok = False
    try:
        fobj = open('/tmp/check', "r")
        for line in fobj:
            if wert in line:
                id_ok = True
        fobj.close()
    except  UnboundLocalError:
        pass

Code: Alles auswählen

# Überprüfe ob ID aus pidpath aktuell ist
        fobj = open('/tmp/check', "r")
        for line in fobj:
            if wert in line:
                id_ok = True
            else:
                id_ok = False
        fobj.close()

Code: Alles auswählen

TITEL = 'Lieferanten-Bestellungen'

# Programm
def auftrag():
    from bestellorder_lieferant import auftragkontrolle
    auftragkontrolle()


class DialogFenster(tkSimpleDialog.Dialog):
    def foo():
        '''
        Das Dialog-Fenster besteht aus den Dialogen "ok" und "cancel".
        Die weitere Beschreibung über die Rolle und Funktionalität,
        muß noch erarbeitet werden.
        '''

    def body(self, master):
        self.title(TITEL)
        self.auftraginfo = 'Programm für %s starten?' % TITEL
        self.namen = Label(master, text=self.auftraginfo)
        self.namen.pack(side=LEFT)

    def apply(self):
        self.result = True
        return


def start_bestellorder(title):
    def foo():
        '''
        Haupt- und Einstiegsfunktion der Auftragsabwicklung. Sie startet einen
        Dialog, in dem das Paket "bestellorder_lieferant" gestartet werden kann.
        :param TITEL: string mit dem Titel des Dialogfensters
        :param AUFTRAGINFO: string mit Informationen zum Auftrag
        '''

    NamenDialog = DialogFenster(Tk())

    # Liste Dateien aus pidpath_path auf
    exist = os.listdir(pidpath_path)
    # Überprüfe pidpath in Liste
    if pidpath in exist:
        fobj = open('/tmp/%s' % pidpath, "r")
        for line in fobj:
            wert = line
        fobj.close()

    # Erstelle Datei über aktive IDś
    os.system('ps -u $USER > /tmp/check 2>/dev/null')

    # Überprüfe ob ID aus pidpath aktuell ist
    id_ok = False
    try:
        fobj = open('/tmp/check', "r")
        for line in fobj:
            if wert in line:
                id_ok = True
        fobj.close()
    except  UnboundLocalError:
        pass

    # ID ist aktuell, Abbruch
    if id_ok == True:
        print "Programm läuft schon mit PID:", wert
        sys.exit(1)

    # ID ist nicht aktuell, pidpath wird gelöscht
    if id_ok == False:
        try:
            os.remove('/tmp/%s' % pidpath)
        except OSError:
            pass

    try:
        if NamenDialog.result == True:
            exist = auftrag().os.getpid()
            fobj = open('/tmp/%s' % pidpath, 'w')
            fobj.write(str(exist))
            fobj.close()
        else:
            info = 'Der Programmstart für %s wurde abgebrochen!' % title

    except (ImportError, OSError):
        info = 'Es gab einen Fehler, das Programm für %s konnte nicht gestartet werden!' % title

    tkMessageBox.showinfo('Info', info)
    Tk().destroy()

if __name__ == "__main__":
    start_bestellorder(TITEL)

Code: Alles auswählen

if a: pass
if not a: pass

Code: Alles auswählen

if a: pass
else: pass

Code: Alles auswählen

with  open('/tmp/check') as inf:
  id_ok = wert in inf.readlines()

Code: Alles auswählen

TITEL = 'Lieferanten-Bestellungen'


class DialogFenster(tkSimpleDialog.Dialog):
    def foo():
        '''
        Das Dialog-Fenster besteht aus den Dialogen "ok" und "cancel".
        Die weitere Beschreibung über die Rolle und Funktionalität,
        muß noch erarbeitet werden.
        '''

    def body(self, master):
        self.title(TITEL)
        self.auftraginfo = 'Programm für %s starten?' % TITEL
        self.namen = Label(master, text=self.auftraginfo)
        self.namen.pack(side=LEFT)

    def apply(self):
        self.result = True
        return


# Programmaufruf
def auftrag():
    from bestellorder_lieferant import auftragkontrolle
    auftragkontrolle()


def start_bestellorder(title):
    def foo():
        '''
        Haupt- und Einstiegsfunktion der Auftragsabwicklung. Sie startet einen
        Dialog, in dem das Paket "bestellorder_lieferant" gestartet werden kann.
        :param TITEL: string mit dem Titel des Dialogfensters
        :param AUFTRAGINFO: string mit Informationen zum Auftrag
        '''

    NamenDialog = DialogFenster(Tk())

    # Liste Dateien aus pidpath_path auf
    exist = os.listdir(pidpath_path)
    # Überprüfe pidpath in Liste
    if pidpath in exist:
        with  open('/tmp/%s' % pidpath,'r') as inf:
            for line in inf:
                wert = line
    else:
        wert = 'not_id'

    # Erstelle Datei über aktive IDś
    os.system('ps -u > /tmp/id_check 2>/dev/null')

    # Überprüfe ob ID aus pidpath aktuell ist
    with  open('/tmp/id_check','r') as inf:
        for i in inf:
            if wert in i:
                id_ok = True
                break
            else:
                id_ok = False

    # Abbruch, wenn ID aktuell
    # pidpath löschen, wenn ID nicht aktuell
    if id_ok:
        info = 'Programm läuft schon mit PID: %s' % wert
        tkMessageBox.showinfo('Info', info)
        Tk().destroy()
        sys.exit(1)
    else:
        try:
            os.remove('/tmp/%s' % pidpath)
        except OSError:
            pass

    try:
        if NamenDialog.result:
            exist = os.getpid()
            with  open('/tmp/%s' % pidpath,'w') as inf:
                inf.write(str(exist))

            auftrag()
        else:
            info = 'Der Programmstart für %s wurde abgebrochen!' % title

    except (ImportError, OSError):
        info = 'Es gab einen Fehler, das Programm für %s konnte nicht gestartet werden!' % title

    tkMessageBox.showinfo('Info', info)
    Tk().destroy()

if __name__ == "__main__":
    start_bestellorder(TITEL)

Code: Alles auswählen

subprocess.Popen(['touch', auftrag()])

Code: Alles auswählen

root = Tk()

Code: Alles auswählen

def demo_func(param1, param2, ..., root) # <- `root` ist neu!
    # irgend welcher Code
    # folgende Zeile auskommentieren
    # root = Tk()
    # irgend welcher Code
    another_gui_func(param1, param2, ..., root) # <- wir "schleifen" `root` durch!

Code: Alles auswählen

def demo_func(param1, param2, ..., root=None) # <- `root` wird nun "optional"
    # wenn es noch kein root-Objekt gibt, legen wir es hier an.
    if root is None:
        root = Tk()
    # irgend welcher Code

Code: Alles auswählen

from Tkinter import *
import tkSimpleDialog, tkMessageBox

# Programm
TITEL = ''
AUFTRAGINFO = ''
dialog_result = set()

def dialog_func(title, info, root=None): # <- `root` wird nun "optional"
    # wenn es noch kein root-Objekt gibt, legen wir es hier an.
    if root is None:
        root = Tk()
        DialogFenster = tkMessageBox.askquestion(title, info)
        root.destroy()
        global result
        if DialogFenster == 'yes':
            result = True
        elif DialogFenster == 'no':
            result = False
        dialog_result.add(result)


def info_func(title, info, root=None): # <- `root` wird nun "optional"
    # wenn es noch kein root-Objekt gibt, legen wir es hier an.
    if root is None:
        root = Tk()
        tkMessageBox.showinfo(title, info)
        root.destroy()


if __name__ == "__main__":
    dialog_func(TITEL, AUFTRAGINFO)
    info_func(TITEL, AUFTRAGINFO)

Code: Alles auswählen

from a import dialog_result, dialog_func, info_func

TITEL = 'Lieferanten-Bestellungen'
AUFTRAGINFO = 'Programm für %s starten?' % TITEL

dialog_func(TITEL, AUFTRAGINFO, root=None)

if dialog_result:
    if True in dialog_result:
        result = True
    elif False in dialog_result:
        result = False

if result:
    info = 'Es funktioniert.'
    info_func(TITEL, info, root=None)
else:
    info = 'Abbruch'
    info_func(TITEL, info, root=None)

Code: Alles auswählen

def say_hello():
    print "Hello, World"

say_hello()

Code: Alles auswählen

def get_greeting():
    return "Hello, World"

name = get_greeting()
print name

Code: Alles auswählen

def get_greeting(name):
    return "Hello, %s" % name

name = get_greeting()
name = get_greeting("World")
print name

Code: Alles auswählen

name = "Fritz"
get_greeting("World")
print name

Code: Alles auswählen

def get_greeting(name="World"):
    return "Hello, %s" % name

print get_greeting()

Code: Alles auswählen

from Tkinter import *
import tkMessageBox

dialog_result = set()

def dialog_func(title, info):
    root = Tk()
    DialogFenster = tkMessageBox.askquestion(title, info)
    root.destroy()
    dialog_result.clear()    # Liste leeren
    if DialogFenster == 'yes':
        result = True
    elif DialogFenster == 'no':
        result = False
    dialog_result.add(result)


def info_func(title, info):
    root = Tk()
    tkMessageBox.showinfo(title, info)
    root.destroy()

Code: Alles auswählen

from GUI-Modul import dialog_result, dialog_func, info_func

TITEL = 'Lieferanten-Bestellungen'
AUFTRAGINFO = 'Programm für %s starten?' % TITEL

dialog_func(TITEL, AUFTRAGINFO)

if True in dialog_result:
    info = 'Es funktioniert.'
    info_func(TITEL, info)
elif False in dialog_result:
    info = 'Abbruch'
    info_func(TITEL, info)

Code: Alles auswählen

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

### Import Module
import os, re
from gui_dialog import dialog_result, dialog_func, showinfo_func



# Programmaufruf
class prog_control(object):
    def description():
        '''
        Kontrollfunktion für Start von Programmen.
        - Übergabe der aktuellen PID des Auftrags-Modul
        - Überprüfung, ob das Auftrags-Modul evtl. schon läuft
        - Freigabe des Auftrags-Modul, wenn kein Doppelstart vorliegt
        - Auswahldialog bei Doppelstart
        -- Auswahlmöglichkeit Abbruch (Nein), schon gestartetes Auftrags-Modul läuft weiter
        -- Auswahlmöglichkeit Beenden (Ja), schon gestartetes Auftrags-Modul wird beendet
        Bei schon gestartetem Programm, wird ein nochmaliges starten
        des gleichen Programmes verhindert. Gleichzeitig wird ein
        Dialog zum Beenden des aktiven Programmes angeboten.
        :param programm: string, Programmnamen
        :param titel: string, Programm-Bezeichnung
        :param pid_current: int, aktuelle PID des gestarteten Programmes
        '''
    def __init__(self, programm, titel, pid_current):
        self.programm = programm
        self.titel = titel
        self.pid_current = pid_current

        # Die ersten 15 Stellen des Programmnamens
        self.prog_short = '{}'.format(self.programm[:15])

        self.prog_pid = ''
        self.pid_ok = False
        self.pid_diff = 0

    def prog_list(self):
        # Erstelle Datei über aktive IDś
        os.system('ps -u $USER > /tmp/id_check 2>/dev/null')
        os.system('ps -u > /tmp/id_check2 2>/dev/null')

    def prog_check(self):
        # Überprüfe ob ID aus pidpath aktuell ist
        with  open('/tmp/id_check','r') as inf:
            for i in inf:
                if self.prog_short in i:
                    line = re.sub('^[ ]+', '', i)
                    self.prog_pid = line.partition(' ')[0]
                    self.pid_ok = True
                    break

        if not self.pid_ok:
            with  open('/tmp/id_check2','r') as inf:
                for i in inf:
                    if self.programm in i:
                        line = re.sub('[ ]+', '-', i)
                        self.prog_pid = line.partition('-')[2]
                        self.prog_pid = self.prog_pid.partition('-')[0]
                        self.pid_ok = True
                        break
                    else:
                        self.pid_ok = False

        if self.prog_pid is not None and self.pid_current is not None:
            self.pid_diff = (int(self.prog_pid) - int(self.pid_current))
        else:
            self.pid_diff = 1

    def prog_evaluation(self):
        # Programmstart, wenn Programm nicht schon läuft.
        # Bei schon laufendem Programm, erfolgt ein
        # Dialog über Abbruch oder Programmende des schon laufenden
        # Programmes. So besteht die Möglichkeit, bei nochmaligen
        # Starten des Programmes, das laufende Programm zu beenden.

        if self.pid_ok is True and self.pid_diff is not 0:
            info = '''Programm läuft schon mit PID: %s
Möchten Sie dieses Programm beenden?''' % self.prog_pid
            dialog_result.clear()
            dialog_func(self.titel, info)

            if True in dialog_result:
                os.kill(int(self.prog_pid), signal.SIGTERM)
                os.kill(int(self.pid_current), signal.SIGTERM)
                info = 'Programm mit PID: %s wird beendet' % self.prog_pid
                showinfo_func(self.titel, info)
                sys.exit(1)
            else:
                os.kill(int(self.pid_current), signal.SIGTERM)
                sys.exit(1)
        else:
            try:
                pass
            except OSError:
                pass

if __name__ == "__main__":
    f = prog_control(programm, titel, pid_current)
    f.prog_list()
    f.prog_check()
    f.prog_evaluation()

Code: Alles auswählen

PROGRAMM = 'bestellorder_lieferant.py'
TITEL = 'Lieferanten-Bestellungen'
AUFTRAGINFO = 'Programm für %s starten?' % TITEL


### Programm ###
def start_bestellorder():
    def start_description():
        '''
        Einstiegs- und Kontrollfunktion der Auftragsabwicklung.
        Ziel dieser Funktion, ist das kontrollierte Starten des Moduls
        "bestellorder_lieferant.py". Die Kontrollfunktion wird durch das
        Modul "prog_check.py" gesteuert.
        Folgende Parameter werden dazu benötigt:
        :param PROGRAMM: string, Programmnamen
        :param TITEL: string, Programm-Bezeichnung
        :param pid_current: int, aktuelle PID des gestarteten Programmes
        '''

    # PID für dieses gestartete Modul
    pid_current = os.getpid()

    #Kontrollmodul in der startphase
    def prog_check(PROGRAMM, TITEL, pid_current):
        f = prog_control(PROGRAMM, TITEL, pid_current)
        f.prog_list()
        f.prog_check()
        f.prog_evaluation()

    prog_check(PROGRAMM, TITEL, pid_current)

    # Dialog-Fenster
    # Start oder Abbruch
    dialog_func(TITEL, AUFTRAGINFO)

    try:
        if True in dialog_result:
            pass
        elif False in dialog_result:
            info = 'Der Programmstart für %s wurde abgebrochen!' % TITEL
            showinfo_func(TITEL, info)
            sys.exit(1)

    except (ImportError, OSError):
        info = 'Es gab einen Fehler, das Programm für %s konnte nicht gestartet werden!' % TITEL
        showinfo_func(TITEL, info)

... hier folgt dann der Haupt-Code für die Auftragsverwaltung.