Flexibles Menü, zum Handeln spaltengetrennter Dateien

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 FILENAME, HEADINGS, MAX_LINES_PER_SEGMENT
from privatparam import LISTFILTER, CASE_SENSITIV
from filestart import fileopen


# Temporäre Datei
CHANCE = 'chance.txt'
# Kopie von Datendatei
COPYDATA = 'copy#{}'.format(FILENAME)


def datacheck():
    if not os.path.exists(os.path.join(os.getcwd(), COPYDATA)):
        with codecs.open(FILENAME, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            write_csv(COPYDATA, [row for row in reader])
    return COPYDATA


def datafind():
    return {True: COPYDATA,
            False: FILENAME
            }[os.path.exists(os.path.join(os.getcwd(), COPYDATA))]


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 get_formatted_table(menupoint, HEADINGS, contents, spacing=4,
                                                numeration_width=10):
    lines = [HEADINGS] + contents
    column_widths = [max(len(item) for item in column_items)
                     for column_items in zip(*lines)]
    total_width = sum(column_widths) + (len(column_widths) - 1) * spacing
    total_width += numeration_width
    dashed_line = total_width * '-'
    blank_line = total_width * ' '
    numeration_spec = '{{:>{}}}'.format(numeration_width)
    column_specs = ['{{:{}}}'.format(width) for width in column_widths]
    line_template = numeration_spec + (spacing * ' ').join(column_specs)
    headline = line_template.format('Nummer: ', *HEADINGS)
    head_items = [dashed_line, headline, blank_line, dashed_line]
    formatted_lines = head_items[:]
    dataline = dict()
    for line_number, text_items in enumerate(contents, 1):
        needs_headings = (line_number % MAX_LINES_PER_SEGMENT == 0)
        dataline[line_number] = [text_items]
        if needs_headings:
            formatted_lines.extend(head_items)
        numeration_string = '{}: '.format(line_number)
        formatted_lines.append(line_template.format(numeration_string,
                                                    *text_items))
        formatted_lines.append(blank_line)
    formatted_lines.append(dashed_line)
    print('\n'.join(formatted_lines))
    return selection(menupoint, dataline)


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


def search_entry(menupoint, result):
    entry = input('\nSuchbegriff: ')
    if entry:
        print("\nListe wird nach Suchbegriff durchsucht!")
        if not type(result) == list:
            with open(datafind(), 'r') as infile:
                reader = csv.reader(infile, delimiter="\t",
                                                        quotechar="^")
                contents = [row for row in reader if any(entry in
                        (x, x.lower())[CASE_SENSITIV] for x in row)]
        elif type(result) == list:
            contents = [row for row in result if any(entry in
                        (x, x.lower())[CASE_SENSITIV] for x in row)]
        if contents:
            if len(contents) == 1:
                print("\nDie Suche ergab folgendes Ergebnis:")
            else:
                print("\nDie Suche ergab folgende Ergebnisse:")
            return get_formatted_table(menupoint, HEADINGS, contents)
        else:
            print('\nEs liegen keine Ergebnisse \
                            \nzu dem Suchbegriff < %s > vor\n' % entry)
    else:
        print("\nAbbruch, Sie haben keine Eingabe gemacht!")
        return


def selection(menupoint, result):
    if LISTFILTER == 'ja' and len(result) > 1:
        if input('Möchten Sie das Ergebnis weiter filtern? \
                            \n< ja / [TASTE] für Abbruch > ') == 'ja':
            return search_entry(menupoint, [row for key in
                                        result for row in result[key]])
    if menupoint == 'suchen':
        return
    contents = list()
    while True:
        try:
            selection = int(input(' \
                        \nZeilennummer oder [TASTE] für Abbruch: '))
            if 0 != selection <= len(result):
                data = [row for key in result if key == selection
                        for row in result.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)
                contents = [row for key in result if key != selection
                        for row in result[key]]
                if len(result) > 1 and input('Weitere Auswahl treffen? \
                            \n< ja / [TASTE] für Abbruch > ') == 'ja':
                    return get_formatted_table(menupoint, HEADINGS,
                                                            contents)
                break
            else:
                print('\nFalsche Eingabe, bitte wählen Sie eine Zahl \
                                    \nvon 1 bis %s aus!' % len(result))
        except (ValueError, IndexError):
            break
    if not os.path.exists(os.path.join(os.getcwd(), CHANCE)):
        return
    elif menupoint == 'ändern':
        load(menupoint)
    elif menupoint == 'löschen':
        if input('\nAusgewählte Datenzeile löschen? \
                            \n< ja / [TASTE] für Abbruch > ') == 'ja':
            print('\nDatenzeile wird gelöscht!')
            remove_entry(menupoint)
    return


def add_entry(menupoint):
    print('')
    newdata = list()
    newdata = ([(input('Eintrag zu: %s > ' % info))
                                                for info in HEADINGS])
    if newdata[0] and newdata[1]:
        if input('\nEintrag in die Liste übernehmen? \
                \n< %s >\n< ja / [TASTE] für Abbruch > '
                                                % newdata) == 'ja':
            print("\nEintrag wird hinzugefügt\n")
            writeappend_csv(datacheck(), [newdata])
            sort(menupoint)
        else:
            print("\nEintrag wird nicht hinzugefügt\n")
    return


def load(menupoint):
    if not os.path.exists(os.path.join(os.getcwd(), CHANCE)):
        return search_base(menupoint)
    fileopen(CHANCE) # Datei mit Standardprogramm öffnen 
    with open(CHANCE, 'r') as zielfile:
        reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
        olddata = [row for row in reader]
    if input('\nÄnderung übernehmen? \
                            \n< ja / [TASTE] für Abbruch > ') == 'ja':
        with open(CHANCE, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            writeappend_csv(datacheck(), [row for row in reader])
        write_csv(CHANCE, olddata)
        remove_entry(menupoint)
    else:
        print("\nDie Änderungen werden nicht übernommen!\n")
    return


def remove_entry(menupoint):
    if not os.path.exists(os.path.join(os.getcwd(), CHANCE)):
        return search_base(menupoint)
    olddata = dict()
    with codecs.open(CHANCE, 'r') as zielfile:
        reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
        for row in reader:
            olddata[tuple(row)] = tuple(row)
    with codecs.open(datacheck(), 'r') as zielfile:
        reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
        newdata = [row for row in reader if not
                                            olddata.get(tuple(row))]
    write_csv(datafind(), newdata)
    sort(menupoint)
    return


def save(menupoint):
    if os.path.exists(os.path.join(os.getcwd(), COPYDATA)):
        if input('\nMöchten Sie die Datei < %s >, \
                \nmit den gemachten Änderungen aktualisieren? \
                \n< ja / [TASTE] für Abbruch > ' % FILENAME) != 'ja':
            print('\nOriginaldatei < %s > wird nicht mit den \
                    \ngemachten Änderungen aktualisiert!' % FILENAME)
            return
        print('\nOriginaldatei < %s > wird mit den \
                    \ngemachten Änderungen aktualisiert!' % FILENAME)
        with codecs.open(COPYDATA, 'r') as zielfile:
            reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
            write_csv(FILENAME, [row for row in reader])
        return os.remove(COPYDATA)
    else:
        print('\nEs sind keine Daten zum aktualisieren vorhanden!')
    return


def delete(menupoint):
    if COPYDATA == datafind():
        if input('\nSollen die gemachten Änderungen gelöscht werden? \
                            \n< ja / [TASTE] für Abbruch > ') == 'ja':
            print('\nÄnderungen werden gelöscht!')
            os.remove(COPYDATA)
    else:
        print('\nEs gibt keine Änderungen zum Löschen!')
    return


def sort(menupoint):
    print("\nListe wird sortiert und von \
                                \ndoppelten Datensätzen bereinigt!\n")
    DATAPOOL = datafind()
    with open(DATAPOOL, 'r') as zielfile:
        reader = csv.reader(zielfile, delimiter="\t", quotechar="^")
        write_csv(DATAPOOL, sorted([row for row in reader]))
    return


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:
            if os.path.exists(os.path.join(os.getcwd(), CHANCE)):
                os.remove(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'],
    ["Änderungen übernehmen", save, 'speichern'],
    ["Änderungen löschen", delete, 'löschen'],
    ["Beenden", quit, 'beenden']
]

handle_menu(menu)