Tool zur Dokumentation der Änderungen von Python2 zu Python3 und Suchfunktion.

menu.py

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


import os
import re
import csv
import string
import subprocess
import time
import codecs

from privatparam import datapool, headinfo, headrepetition, listfilter, spelling
from filestart import fileopen


# Temporäre Datei
chance = 'chance.txt'


def write_csv(filename, datenpool):
    with codecs.open(filename, "w") as zielfile:
        writer = csv.writer(zielfile, delimiter="\t", quotechar="^")
        writer.writerows(datenpool)


def writeappend_csv(filename, datenpool):
    with codecs.open(filename, "a") as zielfile:
        writer = csv.writer(zielfile, delimiter="\t", quotechar="^")
        writer.writerows(datenpool)


def spellings(entry):
    if spelling == 0:
        return entry
    elif spelling == 1:
        entry = entry.upper()
        entry = entry.replace('[ä]', 'Ä')
        entry = entry.replace('[ö]', 'Ö')
        entry = entry.replace('[ü]', 'Ü')
        return entry
    elif spelling == 2:
        entry = entry.lower()
        entry = entry.replace('[Ä]', 'ä')
        entry = entry.replace('[Ö]', 'ö')
        entry = entry.replace('[Ü]', 'ü')
        return entry


def head():
    # Index-Spalte zu Liste headinfo
    head = list()
    head.append('Nummer')
    [head.append(line) for line in headinfo]
    return head


def maxsign(bighead, datalist):
    headmax = ([max(len(item) for item in column_items) for column_items in zip(*bighead)])
    resmax = ([max(len(item) for item in column_items) for column_items in zip(*datalist)])

    # Maximale Zeichenbreite von resmax mit headmax vergleichen
    rowmax = dict()
    for i in range(len(headmax)):
        if headmax[i] and i == 0:
            rowmax[i] = headmax[i] + 4
        elif headmax[i] and i > 0:
            rowmax[i] = max(headmax[i], resmax[i - 1]) + 4
    return rowmax


def headline(rowmax, bighead):
    headlist = list()
    for i in range(len(bighead)):
        if i == 0:
            headlist.append((bighead[0] + ': ').rjust(rowmax.get(i)))
        else:
            headlist.append(bighead[i].ljust(rowmax.get(i)))
    separateline = (sum([rowmax.get(i) for i in range(len(rowmax))]) - 2) * '-'
    headprint = '\n'.join([separateline, ('').join(headlist), separateline])
    return separateline, headprint


def fileclean(filename):
    try:
        os.remove(filename)
    except OSError:
        pass


def switch(menupoint, result):
    selection(menupoint, result)


def search_base(menupoint):
    result = 0
    search_entry(menupoint, result)
    return


def search_entry(menupoint, result):
    entry = input('\nSuchbegriff: ')
    entry = spellings(entry)
    if entry:
        print("\nListe wird nach Suchbegriff durchsucht!")
        if not type(result) == list:
            with open(datapool, 'r') as infile:
                reader = csv.reader(infile, delimiter="\t", quotechar="^")
                result = [row for row in reader if any(entry in x for x in row)]
        elif type(result) == list:
                result = [row for row in result if any(entry in x for x in row)]
        if not result:
            print('\nEs liegen keine Ergebnisse zu dem Suchbegriff %s vor\n' % entry)
            return
        else:
            selection(menupoint, result)
            return
    return


def selection(menupoint, result):
    if result:
        # Kopfzeile mit Indexspalte kompletieren
        bighead = head()

        # Maximale Zeichenbreite
        rowmax = maxsign([bighead], result)

        # Kopfzeile
        separateline, headprint = headline(rowmax, bighead)

        # Index erstellen und die einzelnen Spalten zeilenweise einlesen
        # Zuweisen der maximalen Zeichenbreite für Printausgabe.
        # Einheitliches, spaltenbezogenes Printlayout
        dataline = dict()
        printline = list()
        for index, row in enumerate(result):
            data = list()
            printdata = list()
            data.append(index + 1)
            printdata.append((str(index + 1) + ': ').rjust(rowmax.get(0)))
            printdata.append(row[0].ljust(rowmax.get(1)))
            for i in range(1, len(row)):
                data.append(row[i])
                if rowmax.get(i + 1):
                    printdata.append(row[i].ljust(rowmax.get(i + 1)))
            dataline[data[0]] = [row]
            printline.append(printdata)

        if len(result) == 1:
            print("\nDie Suche ergab folgendes Ergebnis:")
        else:
            print("\nDie Suche ergab folgende Ergebnisse:")

        # Ausgabe Konsole/Terminal
        # :param:headrepetition, Wiederholung von Kopzeile
        # bei Ausgabe großer Zeilenmengen
        print(headprint)
        if headrepetition > 0:
            counter = headrepetition
            for index, row in enumerate(printline):
                print(''.join(row))
                if index == counter:
                    counter += headrepetition
                    print(headprint)
        else:
            for row in printline:
                print(''.join(row))
        print(separateline)

        if listfilter == 'ja' and len(dataline) > 1:
            selectchance = input('Möchten Sie das Ergebnis weiter filtern?\n< ja / [TASTE] > ')
            if selectchance == 'ja':
                search_entry(menupoint, result)
                return

    if menupoint == 'suchen':
        return

    result = list()
    while True:
        try:
            selection = int(input('\nZeilennummer oder [TASTE] für Abbruch: '))
            if 0 != selection <= len(dataline):
                for key in dataline:
                    if key == selection:
                        data = dataline.get(selection)
                        print("\nDatensatz wird zur Auswahl hinzu gefügt!\n")
                        if os.path.exists(os.path.join(os.getcwd(), chance)):
                            writeappend_csv(chance, data)
                        else:
                            write_csv(chance, data)
                    elif selection <= len(dataline):
                        for row in dataline.get(key):
                            result.append(row)
                break
            else:
                print('\nFalsche Eingabe, bitte wählen Sie eine Zahl von 1 bis %s aus!' % len(dataline))
        except (ValueError, IndexError):
            print('\nEingabefehler, Sie haben keine Zahl von 1 bis %s ausgeählt,\nder Vorgang wird abgebrochen!' % len(dataline))
            return

    if len(dataline) > 1:
        selectchance = input('Weitere Auswahl treffen?\n< ja / [TASTE] > ')
        if selectchance == 'ja':
            switch(menupoint, result)
    if menupoint == 'ändern':
        load(menupoint)
    elif menupoint == 'löschen':
        remove_entry(menupoint)
    elif menupoint == 'speichern':
        save(menupoint)
    return


def add_entry(menupoint):
    newdata = list()
    while True:
        for info in headinfo:
            print('')
            while True:
                infoline = input('Eintrag zu: %s > ' % info)
                if infoline:
                    newdata.append(infoline)
                    break
        if newdata[0] and newdata[1]:
            take = input('\nMöchten sie diesen Eintrag in die Liste übernehmen?\n %s\n< ja / [TASTE] > ' % newdata)
            if take == 'ja':
                print("\nEintrag wird hinzugefügt\n")
                writeappend_csv(datapool, [newdata])
                sort(menupoint)
                break
            else:
                print("\nEintrag wird nicht hinzugefügt\n")


def load(menupoint):
    if not os.path.exists(os.path.join(os.getcwd(), chance)):
        search_base(menupoint)
        return

    while True:
        fileopen(chance) # Textdatei chance mit Standardprogramm des Betriebsystems öffnen
        with open(chance, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            olddata = [row for row in reader]
        waitchance = input('\nÄnderung übernehmen?\n< ja / [TASTE] > ')
        if waitchance == 'ja':
            with open(chance, 'r') as zielfile:
                reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
                [writeappend_csv(datapool, [row]) for row in reader]
            write_csv(chance, olddata)
            remove_entry(menupoint)
            break
        else:
            print("\nDie Änderungen werden nicht übernommen!\n")
            break
    return


def remove_entry(menupoint):
    if not os.path.exists(os.path.join(os.getcwd(), chance)):
        search_base(menupoint)
        return

    while True:
        with codecs.open(chance, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            for row in reader:
                olddata = list(row)
        with codecs.open(datapool, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            newlist = [row for row in reader if olddata != row]
        write_csv(datapool, newlist)
        sort(menupoint)
        break


def sort(menupoint):
    print("\nListe wird sortiert und von doppelten Datensätzen bereinigt!\n")
    while True:
        newlist = set()
        with open(datapool, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            for row in reader:
                newlist.add(tuple(row))
        write_csv(datapool, sorted(newlist))
        break


def quit(menupoint):
    print("\nProgramm wird beendet!\n")
    exit()


def handle_menu(menu):
    while True:
        print('\n<<< Hauptmenü >>>')
        for index, row in enumerate(menu, 1):
            print("{}  {}".format(index, row[0]))
        try:
            fileclean(chance)
            choice = int(input("Nummer: ")) - 1
            menu[choice][1](menu[choice][2])
        except (ValueError, IndexError):
            print("\nBitte nur Zahlen im Bereich 1 - {} eingeben\n".format(
                                                                    len(menu)))


menu = [
    ["Eintrag suchen", search_base, 'suchen'],
    ["Eintrag hinzufügen", add_entry, 'hinzufügen'],
    ["Eintrag ändern", load, 'ändern'],
    ["Eintrag löschen", remove_entry, 'löschen'],
    ["Beenden", quit, 'beenden']
]

handle_menu(menu)

privatparam.py

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

'''
Nehmen Sie hier Ihre persöhnliche Einstellungen vor.

:param:datapool
Datei in dem die Daten enthalten sind.

:param:headinfo
Spaltenbenennung, bezogen auf die Datendatei.
Es müssen dazu nicht alle Spalten der Datendatei aufgelistet werden.
Wichtig ist aber, daß die Spaltenangaben von links (Spalte "0")
fortlaufend beginnen!
FALSCH: Spalte[0], Spalte[3], Spalte[4], Spalte[7],
RICHTIG: Spalte[0], Spalte[1], Spalte[2], Spalte[3], Spalte[4], Spalte[5], Spalte[6], Spalte[7],

:param:headrepetition
10 = alle 10 Zeilen
ODER
25 = alle 25 Zeilen
0 = keine Wiederholung

:param:listfilter
Ermöglicht eine weitere Filterung des Suchergebnisses
Mit 'ja' ist der Filter aktiv, mit 'nein' Filter nicht aktiv.

:param:spelling
0 = Groß-/Kleinschreibung wird beachtet
1 = Alle Eingaben werden in Großschreibung umgewandelt
2 = Alle Eingaben werden in Kleinschreibung umgewandelt
'''
# Datendatei
#datapool = 'pythoninfo.txt'
datapool = 'LISTE_ARTIKELGESAMT.txt'

# Kopfzeile
#headinfo = 'Python2', 'Python3', 'Info'
headinfo = 'Hersteller', 'H-Nummer', 'VE', 'Inhalt', 'Beschreibung'

# Wiederholung der Kopfzeile
headrepetition = 20

# Filter
listfilter = 'ja'

# Sucheingabe
spelling = 1