Überprüfung von Modulen in einem Ordner, auf fehlende Pakete mit der Option diese zu installieren und Ausgabe weiterer Fehlermeldungen.

modul_control.py

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

try:
    import sys
    import os
    import time
    import platform
    import shlex
    import subprocess
    import imp
    import pip
    from subprocess import PIPE
except ImportError:
    import sys
    import os
    import time
    import platform
    import shlex
    import subprocess
    import imp
    from subprocess import PIPE



PROG = 'modul_control.py'

# Programm

def info():
    '''
Dieses Modul ist für Linux konzipiert und auf DEBIAN / UBUNTU getestet.
Es überprüft die Lauffähigkeit von Python-Modulen mit der Endung py.
Fehlermeldungen werden in folgender Reihenfolge ausgewertet:
ImportError, NameErrror und BaseException.
Fehlende Pakete für die Funktionsfähigkeit der Module, werden zur
Installation angeboten. Bei Programmende erfolgt eine Fehlerausgabe.
Die Anwendung von modul_control.py ist recht einfach, in dem Sie es
in den Ordner der zu überprüfenden Module stellen und die
Überprüfung aus der Konsole heraus starten.starten.
Sie können den gesamten Ordner oder auch nur ein einzelnes Modul
überprüfen.
'''


# Einstiegsfunktion mit Überprüfung des Betriebssystems
# und Auswahl für Programmstart / Abbruch
def start():
    # Überprüfung des Betriebssystem.
    # Bei Windows erfolgt Abbruch!
    if not platform.platform().startswith('Linux'):
        print ('Sorry, Sie haben kein Linux Betriebssystem! \nmudul_control läuft auf Windows-Systemen nicht!')
        sys.exit(0)

    # Kurzes Programm- und Systeminfo
    print ('Betriebssystem: %s' % platform.platform())
    print ('Python-Version: %s' % platform.python_version())
    print (info.__doc__)

    # Programmstart / Abbruch
    counter = 0
    while counter != 3:
        counter += 1
        print ('\nWählen Sie die Nummer \n1: Programmstart \n2: Abbruch: ')
        decision = raw_input('Nummer: ')
        if decision == '1':
            print ('\n%s wird gestartet!' % PROG)
            return
        elif decision == '2':
            print ('\n%s, Abbruch!' % PROG)
            sys.exit(0)
        else:
            if counter < 3:
                print ('\nEingabefehler, bitte wählen Sie Ihre Option!')
            else:
                print ('\nEingabefehler, %s wird beendet!' % PROG)
                sys.exit(0)


# Funktion zur Auflistung
# aller Dateien des aktuellen Ordners
# oder manuelle Dateiauswahl
filelist = list()
def checklist():
    counter = 0
    while counter != 3:
        counter += 1
        print ('\nWas soll überprüft werden? \n1: Aktueller Ordner \n2: Manuelle Dateiwahl ')
        review = raw_input('Nummer: ')
        if review == '1':
            PATH = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0])))
            pathlist = os.listdir(PATH)
            for files in pathlist:
                filelist.append(files)
            return
        elif review == '2':
            text = ('\nGeben Sie den Dateinamen mit Endung ein: ')
            fileinput = raw_input(text)
            if fileinput.endswith('.py'):
                filelist.append(fileinput)
                return
        else:
            if counter < 3:
                print ('\nEingabefehler, bitte wählen Sie Ihre Option aus!')
            else:
                print ('\nEingabefehler, Programm wird beendet')
                sys.exit(0)
    print ('\n')


# Funktion zur Überprüfung
# ob Name in Paketliste enthalten ist.
paketline = set()
def namecheck(e_name):
    if not 'python' in e_name:
        modul = 'python-%s' % e_name

    command_line = ('apt-cache', 'search', modul.lstrip('-'))
    process = subprocess.Popen(command_line, shell=False, stdout=subprocess.PIPE)
    output = process.stdout.readlines()
    process.wait()
    for line in output:
        paketline.add(line)


# Funktion zur Überprüfung
# ob ausgewähltes Paket schon installiert ist.
installinfo = list()
def installcheck(paket):
    # Überprüfe ob Paket nicht installiert ist.
    command_line = ('apt-cache', 'policy', paket)
    process = subprocess.Popen(command_line, stdout=subprocess.PIPE)
    output = process.stdout.readlines()
    process.wait()
    if output:
        for info in output:
            if 'Installiert:' in info and not 'Installiert: (keine)' in info:
                print ('\nPaket %s ist installiert!\nÜberprüfen Sie bitte Ihr Modul auf Fehler!\n' % (paket, paket))
            else:
                installinfo.append(info)
                return
    else:
        installinfo.append([])


# Funktion zur Auswahl des Installation-Befehl
# PIP ist momentan noch nicht einsetzbar und
# muß dafür noch erweitert werden!
APT_GET = 'sudo', 'apt-get', 'install', '-y'
APTITUDE = 'sudo', 'aptitude', 'install', '-y'
PIP = 'pip', 'install'
install_command = list()
def command(e_name):
    counter = 0
    while counter != 5:
        print ('\nWelchen Befehl möchten Sie für die\nInstallation von Paketen verwenden?:\n1: {}\n2: {}\n3: {}'.format(APT_GET[1], APTITUDE[1], PIP[0]))
        number = raw_input('Nummer: ')
        counter += 1
        if number == '1':
            print ('\nSie haben %s gewählt!\n' % APT_GET[1])
            print ('Geben Sie Ihr Passwort ein!')
            install_command.append(APT_GET)
            return
        elif number == '2':
            print ('\nSie haben %s gewählt!\n' % APTITUDE[1])
            print ('Geben Sie Ihr Passwort ein!')
            install_command.append(APTITUDE)
            return
        elif number == '3':
            try:
                if e_name == 'pip':
                    print ('\nSie haben %s gewählt!\n' % PIP[0])
                    return
                elif e_name != 'pip':
                    print ('\nNummer %s ist nicht installiert, \nbitte wählen Sie eine andere Option!\n' % number)
            except ImportError:
                if e_name == 'pip':
                    noname(e_name)
                install_command.append(PIP)
                return
        else:
            if counter < 4:
                print ('\nEingabefehler, es gibt keine Nummer %s, \nbitte wählen Sie erneut eine Option!\n' % number)
            else:
                print ('Eingabefehler, Abbruch!')
                keyboardinput = True
                sys.exit()


# Funktion zur Ausführung der Installation von Paketen.
outputerror = list()
def installation(paket):
    for line in install_command:
        commando = list(line)
        commando.append(paket.lstrip('-'))
        break

    counter = 0
    while counter != 4:
        counter += 1
        process = subprocess.Popen(commando, stdout=subprocess.PIPE)
        output = process.stdout.readlines()
        process.wait()
        install = process.returncode
        if output:
            for line in output:
                print (line)
            if install == 0:
                print ('Installation von %s war erfolgreich!\n' % paket)
                counter = 4
                return
        if counter < 4:
            print ('\nInstallationsfehler: %s, die Installation wird wiederholt!' % paket)
            time.sleep(5)
        elif counter == 4:
            outputerror.append('Es ist ein Fehler bei der Installation von aufgetreten, %s konnte nicht installiert werden!' % paket)
            return


# Funktion zu ImportError für,
# Module die kein Paket für die Installation angeboten bekommen,
# sondern nur den Namen des Moduls.
# Hier werden Pakete aus der apt-Paketliste angeboten.
# Die Auswahl des zu installierenden Paketes,
# muß manuell vorgenommen werden.
outputerror = list()
def noname(e_name):
    if not 'python' in e_name:
        modul = 'python-%s' % e_name

    question = ('\nMöchten Sie das Paket %s \naus der Paketliste aussuchen und installieren?\n< ja / nein >: ' % e_name)
    answer = raw_input(question)

    paket = False
    if answer == 'ja':
        namecheck(e_name)
        if paketline:
            print ('\nFolgende Pakete wurden gefunden:\n')
            print ('----------')
            for line in paketline:
                print line
            print ('----------')

            text = ('Geben Sie das zu installierende Paket für %s ein!: ' % e_name)
            paket = raw_input(text)
            installcheck(paket)
            if installinfo:
                command(modul)
                installation(paket)
            else:
                outputerror.append('Eingabefehler, "%s" existiert nicht in der paketquelle!' % paket)
        else:
            print ('\nEs existieren keine Pakete für %s in der Paketliste! \nVielleicht ist der Namen des Moduls falsch geschrieben \noder es handelt sich um ein Fremdpaket, das Sie manuell \ninstallieren müssen! \nEine Installation ist daher nicht möglich!\n' % e_name)
            time.sleep(3)
    elif answer == 'nein':
        outputerror.append('Installation von %s wurde abgebrochen!' % e_name)
    else:
        outputerror.append('Fehlerhafte Eingabe, Installation von %s wurde abgebrochen!' % e_name)


# Funktion zur Überprüfung von Fehlermeldungen.
# Die Reihenfolge ist:
# ImportError und NameError
# BaseException gibt alle restlichen Fehlermeldungen aus.
BaseExceptionInfo = list()
NameErrorInfo = list()
ImportErrorInfo = list()
def modulcheck():
    for prog in filelist:
        if prog.endswith('.py') and prog != PROG:
            datei = prog
            base = os.path.basename(datei)
            modul = base[:(len(base) - 3)]
            try:
                imp.load_source(modul, datei)
                print ('Modul %s ist ok!' % datei)
            except ImportError, e:
                if not 'please install the' in str(e):
                    e_name = e.message.rsplit(None, 2)[-1]
                    namecheck(e_name)
                    if paketline:
                        print ('\nFehler in Datei %s mit Modul %s' % (datei, e_name))
                        noname(e_name)
                        if outputerror:
                            for line in outputerror:
                                result = [line, datei, e]
                                ImportErrorInfo.append(result)
                    else:
                        with open(datei, 'r') as infile:
                            for line in infile:
                                if e_name in line:
                                    result = (datei, e)
                                    ImportErrorInfo.append(result)
                else:
                    e_name = e.message.rsplit(None, 2)[-2]
                    print ('\nFehler in Datei %s mit Modul %s' % (datei, e_name))
                    if 'please install the' in str(e):
                        paket = e.message.rsplit(None, 2)[1]
                        installcheck(paket)
                        if installinfo:
                            print ('Das Paket {} wird für das Starten\ndes Python-Modul {} benötigt.\nDas Paket {} ist nicht installiert!\n\nSoll das Paket {} jetzt installiert werden?'.format(paket, datei, paket, paket))
                            answer = raw_input('< ja / nein >: ')
                            if answer == 'ja':
                                if not install_command:
                                    command(e_name)
                                    installation(paket)
                            elif answer == 'nein':
                                text = ('Installation von %s wurde abgebrochen!' % paket)
                                result = (text, datei, e)
                                ImportErrorInfo.append(result)
                            else:
                                text = ('Fehlerhafte Eingabe, Installation von %s wurde abgebrochen!' % paket)
                                result = (text, datei, e)
                                ImportErrorInfo.append(result)
            except NameError, e:
                e_name = e.message.split('\'')[1]
                namecheck(e_name)
                if paketline:
                    print ('\nFehler in Datei %s mit Modul %s' % (datei, e_name))
                    noname(e_name)
                else:
                    with open(datei, 'r') as infile:
                        for find in infile:
                            if modul in find:
                                result = (datei, e)
                                NameErrorInfo.append(result)
                                break
            except BaseException, e:
                result = (datei, e)
                BaseExceptionInfo.append(result)


# Funktion zur Auswertung von Fehlermeldungen,
# die nicht ImportError entsprechen.
def erroroutput():
    if ImportErrorInfo or NameErrorInfo or BaseExceptionInfo:
        print ('\n\nÜberprüfung ist beendet, \nfolgende Fehler müssen manuell von Ihnen behoben werden!\n')
        for info in ImportErrorInfo:
            if info:
                print ('ImportError:')
                print ('{}\n'.format(info))
        for info in NameErrorInfo:
            if info:
                print ('NameError:')
                print ('{}\n'.format(info))
        for info in BaseExceptionInfo:
            if info:
                print ('BaseException:')
                print ('{}\n'.format(info))
        sys.exit()
    else:
        print ('\nÜberprüfung ist beendet, \nes wurden keine Fehler festgestellt!')
        sys.exit()


def programcontrol():
    start()
    checklist()
    modulcheck()
    erroroutput()

if __name__ == "__main__":
    programcontrol()