Version des Word Extraction Tool v0.42: Fehlerbehebung

KSM sagt:

# -*- Codierung: utf-8 -*-
import os
import win32com.client
import pandas as pd
from pandas import DataFrame
von kiwipiepy importiert Kiwi
# from konlpy.tag import Komoran # For Test(2021-02-21)
# from datetime import datetime
Datum und Uhrzeit importieren
import re
import argparse
Importzeit
Multiprocessing importieren

_version_ = '0.41'‘

Versionsverlauf von #
# v0.42 (24.02.2023): Behebung des Fehlers “Spalte(n) ['DBSchema'] existiert nicht‘ beim Extrahieren von Wörtern ausschließlich aus Dateien im Verzeichnis in_path und nicht aus Datenbanktabellen- oder Spaltenkommentardateien.
# v0.41 (19.02.2023): Das Element “DB-Schema-Auftrittshäufigkeit” (DBSchema_Freq) wurde dem Tabellenblatt „Worthäufigkeit“ hinzugefügt, nachdem Wörter aus Datenbanktabellen und Spaltenkommentardateien extrahiert wurden.
# v0.40 (29.08.2021): Dem Tabellenblatt “Worthäufigkeit” wurde ein Quelleneintrag hinzugefügt, nachdem Wörter aus MS Word-, PowerPoint- und Textdateien extrahiert wurden.
# v0.30 (26.04.2021): Nach dem Extrahieren von Wörtern aus der Datenbanktabelle wurde dem Tabellenblatt “Worthäufigkeit” ein Quellelement hinzugefügt (Spaltenkommentardatei).
# v0.20 (2021-02-21): Multiprocessing-fähige Version
# v0.10 (10.01.2021): Erste Version

def get_word_list(df_text) -> DataFrame:
“”
Extrahiert Substantive aus dem DataFrame des Textextraktionsergebnisses und gibt die endgültige Ausgabe als DataFrame zurück.
:param df_text: Aus der Datei extrahierter Text (DataFrame-Typ)
:return: Extraktionsergebnis von Substantiven und zusammengesetzten Wörtern (1 oder mehrere Substantive, Präfix+Substantiv+Suffix) (Datenrahmentyp)
“”
start_time = time.time()
word_data_list = []

Kiwi = Kiwi()
# tagger = Komoran()
row_idx = 0
for index, row in df_text.iterrows():
row_idx += 1
Wenn row_idx % 100 == 0: # Gib den aktuellen Fortschrittsstatus alle 100 Datensätze aus
print('[pid:%d] current: %d, total: %d, progress: %3.2f%%' %
(os.getpid(), row_idx, df_text.shape[0], round(row_idx / df_text.shape[0] * 100, 2)))
Dateiname = Zeile['Dateiname']
file_type = row['FileType']
Seite = Zeile['Seite']
text = str(row['Text'])
Quelle = (Zeile['Quelle'])
is_db = True, wenn row['FileType'] in ('Tabelle', 'Spalte') enthalten ist, sonst False
is_db_table = True if row['FileType'] == 'table' else False
is_db_column = True if row['FileType'] == 'column' else False
if is_db:
db = row['DB']
schema = row['Schema']
Tabelle = Zeile['Tabelle']
db_schema = row['DBSchema']
if is_db_column:
Spalte = Zeile['Spalte']

if text is None or text.strip() == ”:
weitermachen
versuchen:
# nouns = mecab.nouns(text)
# [O]ToDo: Auszüge einschließlich aufeinanderfolgender Nomenpräfixe (XPN) und Nomenableitungssuffixe (XSN).
# [O]ToDo: Wenn Nomen (NNG, NNP) nacheinander auftreten, extrahieren Sie das zusammengesetzte Nomen, das mit jedem Nomen verbunden ist.
text_pos = [(token.form, token.tag) for token in kiwi.tokenize(text)]
Wörter = [pos für pos, tag in text_pos wenn tag in ['NNG', 'NNP', 'SL']] # NNG: Gattungsname, NNP: Eigenname
pos_list = [x for (x, y) in text_pos]
tag_list = [y for (x, y) in text_pos]
pos_str = ‘/’.join(pos_list) + ‘/’
tag_str = ‘/’.join(tag_list) + ‘/’
iterator = re.finditer('(NNP/|NNG/)+(XSN/)*|(XPN/)+(NNP/|NNG/)+(XSN/)*|(SL/)+', tag_str)
für mo im Iterator:
x, y = mo.span()
falls x == 0:
start_idx = 0
anders:
start_idx = tag_str[:x].count('/')
end_idx = tag_str[:y].count('/')
sub_pos = ”
# falls end_idx – start_idx > 1 und nicht (start_idx == 0 und end_idx == len(tag_list)):
if end_idx – start_idx > 1:
for i in range(start_idx, end_idx):
sub_pos += pos_list[i]
# print('%s[sub_pos]' % sub_pos)
words.append('%s[Compound Word]' % sub_pos) # Register additional morpheme

if len(words) >= 1:
# print(Nomen, Text)
für Wort in Worten:
# print(noun, '\t', text)
data_row = {'FileName': file_name, 'FileType': file_type, 'Page': page, 'Text': text,
‘'Wort': Wort, 'Quelle': Quelle}
if is_db:
data_row['DB'] = db
data_row['Schema'] = schema
data_row['Table'] = Tabelle
data_row['DBSchema'] = db_schema
if is_db_column:
data_row['Column'] = column
word_data_list.append(data_row)
außer Ausnahme als Beispiel:
print(f'[pid:{os.getpid()}] Ausnahme für Text ausgelöst: {text}')
print(ex)

df_result = pd.DataFrame(word_data_list)
drucken(
f'[pid:{os.getpid()}] Anzahl der Eingabetexte:{df_text.shape[0]}, Anzahl der extrahierten Wörter: {df_result.shape[0]}')
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('[pid:%d] get_word_list abgeschlossen. Gesamt: %d, verstrichene Zeit: %s' %
(os.getpid(), df_text.shape[0], elapsed_time))
return df_result

def get_current_datetime() -> str:
return datetime.datetime.now().strftime(“%Y-%m-%d %H:%M:%S.%f”)

def get_ppt_text(file_name) -> DataFrame:
“”
Extrahieren Sie Text aus einer PPT-Datei und geben Sie ihn als DataFrame-Typ zurück.
:param file_name: Eingabedateiname (str-Typ)
:return: Aus der Eingabedatei extrahierter Text
“”
# :return: DataFrame mit Nomen, die mithilfe eines morphologischen Analysators aus dem Text in der Eingabedatei extrahiert wurden.
start_time = time.time()
print('\r\nget_ppt_text: %s' % file_name)
ppt_app = win32com.client.Dispatch('PowerPoint.Application')
ppt_file = ppt_app.Presentations.Open(file_name, True)
Ergebnis # = []
df_data = []
Seitenanzahl = 0
für Folie in ppt_file.Slides:
slide_number = slide.SlideNumber
Seitenanzahl += 1
für Form in Folie.Formen:
shape_text = []
text = ”
if shape.HasTable:
col_cnt = shape.Table.Columns.Count
row_cnt = shape.Table.Rows.Count
for row_idx in range(1, row_cnt + 1):
for col_idx in range(1, col_cnt + 1):
text = shape.Table.Cell(row_idx, col_idx).Shape.TextFrame.TextRange.Text
if text != ”:
text = text.replace(‘\r’, ‘ ‘)
shape_text.append(text)
elif shape.HasTextFrame:
for paragraph in shape.TextFrame.TextRange.Paragraphs():
text = paragraph.Text
if text != ”:
shape_text.append(text)
für Text in shape_text:
if text.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'ppt', 'Page': slide_number, 'Text': text, 'Source': f'{file_name}:{slide_number}:{text}'})
df_text = pd.DataFrame(df_data)
# print(result)
ppt_file.Close()
# print(df_result)
print('text count: %s' % str(df_text. shape[0]))
print('Seitenanzahl: %d' % Seitenanzahl)
# print(df_text.head(10))
# print(df_result.Paragraph)
# gibt df_result zurück
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('[pid:%d] get_ppt_text verstrichene Zeit: %s' % (os.getpid(), elapsed_time))
# gibt get_word_list(df_text) zurück
gib df_text zurück

def get_doc_text(file_name) -> DataFrame:
“”
Extrahiert Text aus einer Dokumentdatei und gibt ihn als DataFrame-Typ zurück.
:param file_name: Eingabedateiname (str-Typ)
:return: Aus der Eingabedatei extrahierter Text
“”
# :return: DataFrame mit Nomen, die mithilfe eines morphologischen Analysators aus dem Text in der Eingabedatei extrahiert wurden.
start_time = time.time()
print('\r\nget_doc_text: %s' % file_name)
word_app = win32com.client.Dispatch(“Word.Application”)
word_file = word_app.Documents.Open(file_name, True)
Ergebnis # = []
df_data = []
Seite = 0
für Absatz in word_file.Paragraphs:
text = paragraph.Range.Text
Seite = paragraph.Range.Information(3) # 3: wdActiveEndPageNumber(Überprüfen Sie die Seitenzahl des Textes)
if text.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'doc', 'Page': page, 'Text': text, 'Source': f'{file_name}:{page}:{text}'})

df_text = pd.DataFrame(df_data)

word_file.Close()
print('text count: %s' % str(df_text. shape[0]))
print('Seitenanzahl: %d' % Seite)
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('[pid:%d] get_doc_text verstrichene Zeit: %s' % (os.getpid(), elapsed_time))
# gibt get_word_list(df_text) zurück
gib df_text zurück

def get_txt_text(file_name) -> DataFrame:
“”
Extrahiert Text aus einer TXT-Datei und gibt ihn als DataFrame-Typ zurück.
:param file_name: Eingabedateiname (str-Typ)
:return: Aus der Eingabedatei extrahierter Text
“”
# :return: DataFrame mit Nomen, die mithilfe eines morphologischen Analysators aus dem Text in der Eingabedatei extrahiert wurden.
start_time = time.time()
print('\r\nget_txt_text: ' + Dateiname)
df_data = []
Zeilennummer = 0
with open(file_name, 'rt', encoding='UTF8′) as file:
für Text in Datei:
Zeilennummer += 1
if text.strip() != ”:
df_data.append({'FileName': file_name, 'FileType': 'txt', 'Page': line_number, 'Text': text, 'Source': f'{file_name}:{line_number}:{text}'})
df_text = pd.DataFrame(df_data)
print('Textanzahl: %d' % df_text.shape[0])
print('Zeilenanzahl: %d' % Zeilennummer)
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('[pid:%d] get_txt_text verstrichene Zeit: %s' % (os.getpid(), elapsed_time))
# gibt get_word_list(df_text) zurück
gib df_text zurück

def make_word_cloud(df_group, now_dt, out_path):
“”
Erstellen einer Wortwolke mit einem DataFrame, der Nomenhäufigkeiten enthält
:param df_group: Nomenhäufigkeits-DataFrame
:param now_dt: Aktuelles Datum und Uhrzeit
:param out_path: Ausgabepfad
:return: None
“”
start_time = time.time()
print('\r\nStart make_word_cloud…')
from wordcloud import WordCloud
import matplotlib.pyplot as plt
import koreanize_matplotlib
# malgun.ttf # NanumSquare.ttf # NanumSquareR.ttf NanumMyeongjo.ttf # NanumBarunpenR.ttf # NanumBarunGothic.ttf
wc = WordCloud(font_path='.\\font\\NanumBarunGothic.ttf',
Hintergrundfarbe='weiß',
max_words=500,
Breite=1800,
Höhe=1000
)

# print(df_group.head(10))
Wörter = df_group.to_dict()['Freq']
# print(words)
# Wörter = df_group.T.to_dict('list')
wc.generate_from_frequencies(words)
wc.to_file('%s\\wordcloud_%s.png' % (out_path, now_dt))
# plt.axis('off')
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('make_word_cloud elapsed time: %s' % elapsed_time)
# plt.imshow(wc)
# plt.show()

# Todo: Text aus der Araea Hangul-Datei extrahieren (hwp)
def get_hwp_text(file_name) -> DataFrame:
passieren

# Todo: Text aus PDF-Datei extrahieren
def get_pdf_text(file_name) -> DataFrame:
passieren

# [O]ToDo: Text aus Tabelle extrahieren, Spaltenkommentar
def get_db_comment_text(file_name) -> DataFrame:
“”
Extrahiert Text aus der Datei db_comment und gibt ihn als DataFrame-Typ zurück.
:param file_name: Eingabedateiname (str-Typ)
:return: Aus der Eingabedatei extrahierter Text
“”
# :return: DataFrame mit Nomen, die mithilfe eines morphologischen Analysators aus dem Text in der Eingabedatei extrahiert wurden.
start_time = time.time()
print('\r\nget_db_comment_text: %s' % file_name)
full_path_file_name = os.path.abspath(file_name)

#-Region Tabellenkommentar
df_table_raw = pd.read_excel(full_path_file_name, sheet_name=0, engine='openpyxl')
df_table = df_table_raw.iloc[:, :4].copy()
df_table.columns = ['DB', 'Schema', 'Tabelle', 'Text']
df_table['FileName'] = full_path_file_name
df_table['FileType'] = 'table'‘
df_table['Page'] = 0
df_table = df_table[df_table.Text.notnull()] # Entferne Zeilen ohne Textwert
df_table['Source'] = df_table['DB'].astype(str) + '.' + df_table['Schema'].astype(str) + '.' + df_table['Table'].astype(str) \
+ '(' + df_table['Text'].astype(str) + ')'‘
#-Endregion

# Region Spaltenkommentar
df_column_raw = pd.read_excel(full_path_file_name, sheet_name=1, engine='openpyxl')
df_column = df_column_raw.iloc[:, :5].copy()
df_column.columns = ['DB', 'Schema', 'Tabelle', 'Spalte', 'Text']
df_column['FileName'] = full_path_file_name
df_column['FileType'] = 'column'‘
df_column['Page'] = 0
df_column = df_column[df_column.Text.notnull()] # Entferne Zeilen ohne Textwert
df_column['Source'] = df_column['DB'].astype(str) + '.' + df_column['Schema'].astype(str) + '.' + df_column['Table'].astype(str) \
+ '.' + df_column['Column'].astype(str) + '(' + df_column['Text'].astype(str) + ')'‘
#-Endregion
df_text = pd.concat([df_column, df_table], ignore_index=True)
df_text['DBSchema'] = df_text['DB'] + '.' + df_text['Schema'] # DB.Schema Wert generiert (2023-02-19)
# print(df_text)
end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
print('[pid:%d] get_db_comment_text verstrichene Zeit: %s' % (os.getpid(), elapsed_time))
print('text count: %s' % str(df_text. shape[0]))
# gibt get_word_list(df_text) zurück
gib df_text zurück

def get_file_text(file_name) -> DataFrame:
“”
Funktion zum Extrahieren von Text aus MS Word-, PowerPoint-, Text- und DB-Kommentardateien (Excel).
:param file_name: Dateiname
:return: Aus der Datei extrahierter Text (DataFrame-Typ)
“”
df_text = DataFrame()
if file_name.ends with(('.doc', '.docx')):
df_text = get_doc_text(file_name)
elif file_name.endswith(('.ppt', '.pptx')):
df_text = get_ppt_text(file_name)
elif file_name.endswith('.txt'):
df_text = get_txt_text(file_name)
elif file_name.endswith(('.xls', '.xlsx', '.xlsb')):
df_text = get_db_comment_text(file_name)
gib df_text zurück

# Todo: Parallele Verarbeitung (separate Verarbeitung von db_comment_file und in_path, Aufteilung der Verarbeitung, falls db_comment_file groß ist)
def main():
“”
Extrahieren Sie Text aus Dateien in den Unterordnern des angegebenen Pfads, extrahieren Sie Substantive aus jedem Text und speichern Sie diese als Excel-Datei.
:return: None
“”

Einrichtung der Argumentanalyse und -verwendung für die Region # ————————————————————-
# parser = argparse.ArgumentParser(usage='usage test', description='description test')
usage_description = r”””— Beschreibung —
Eines der beiden ist erforderlich: db_comment_file oder in_path.

Ausführungsbeispiel
1. Text und Wörter aus der Datei extrahieren: Eingabepfad und Ausgabepfad angeben
python word_extractor.py –multi_process_count 4 –in_path .\\test_files –out_path .\out

2. Text und Wörter aus DB-Kommentaren extrahieren: db_comment_file und out_path angeben
python word_extractor.py –db_comment_file “table,column comments.xlsx” –out_path .\out

3. Text und Wörter aus Datei und Datenbankkommentar extrahieren: db_comment_file, in_path und out_path angeben
python word_extractor.py –db_comment_file “table,column comments.xlsx” –in_path .\\test_files –out_path .\out

* DB-Tabelle, Spaltenkommentardateiformat
– Erstes Tabellenblatt (Tabellenkommentar): DBName, SchemaName, Tabellenname, Tabellenkommentar
– Zweites Blatt (Spaltenkommentar): DBName, SchemaName, Tablename, ColumnName, ColumnComment”””

# ToDo: Option hinzufügen: Extrahieren von zusammengesetzten Wörtern, Extrahieren von englischen Zeichen, Ausschließen von einstelligen englischen Zeichen, …
parser = argparse.ArgumentParser(description=usage_description, formatter_class=argparse.RawTextHelpFormatter)
Füge das Namensargument # hinzu.
parser.add_argument('–multi_process_count', required=False, type=int,
help='Anzahl der Multiprozesse, die Text- und Wortextraktion gleichzeitig ausführen sollen (falls nicht angegeben, wird die (logische) CPU-Anzahl verwendet)')
parser.add_argument('–db_comment_file', required=False,
Hilfe='Dateiname mit Kommentarinformationen zur Datenbanktabelle, Spalte (z. B. comment.xlsx)')
parser.add_argument('–in_path', required=False, help=r'Pfad zur Eingabedatei (ppt, doc, txt) (z. B. .\in)')
parser.add_argument('–out_path', required=True, help=r'Ausgabedateipfad (xlsx, png) (z. B. .\out)')

args = parser.parse_args()

if args.multi_process_count:
multi_process_count = int(args.multi_process_count)
anders:
multi_process_count = multiprocessing.cpu_count()

db_comment_file = args.db_comment_file
if db_comment_file is not None and not os.path.isfile(db_comment_file):
print('db_comment_file not found: %s' % db_comment_file)
exit(-1)

in_path = args.in_path
out_path = args.out_path
drucken('--------------------')
print('Word Extractor v%s start — %s' % (_version_, get_current_datetime()))
print('##### arguments #####')
print('multi_process_count: %d' % multi_process_count)
print('db_comment_file: %s' % db_comment_file)
print('in_path: %s' % in_path)
print('out_path: %s' % out_path)
drucken('--------------------')
# endregion Args Parse & Usage setup ————————————————————-

start_time = time.time()

df_text = DataFrame() Text aus der #-Datei gelesen
df_result = DataFrame() Wort aus # df_text extrahiert
Dateiliste = []
if in_path is not None and in_path.strip() != ”:
print('[%s] Start Get File List…' % get_current_datetime())
in_abspath = os.path.abspath(in_path) # os.path.abspath('.') + '\\test_files'‘
file_types = ('.ppt', '.pptx', '.doc', '.docx', '.txt')
for root, dir, files in os.walk(in_abspath):
für Datei in sortiert(Dateien):
Auszuschließende #-Dateien
if file.startswith('~'):
weitermachen
Einzuschließende #-Dateien
if file.endswith(file_types):
file_list.append(root + '\\' + file)

print('[%s] Abrufen der Dateiliste abgeschlossen.' % get_current_datetime())
print('— Dateiliste —')
print(‘\n’.join(file_list))

if db_comment_file is not None:
file_list.append(db_comment_file)

print('[%s] Start Get File Text…' % get_current_datetime())
with multiprocessing.Pool(processes=multi_process_count) as pool:
mp_text_result = pool.map(get_file_text, file_list)
df_text = pd.concat(mp_text_result,ignore_index=True)
print('[%s] Dateitext abrufen abgeschlossen.' % get_current_datetime())
Die Textextraktion ist bis # abgeschlossen. Die Wortextraktion beginnt weiter unten.

# ———- Parallele Ausführung ———-
print('[%s] Start Get Word from File Text…' % get_current_datetime())
import math
chunk_size = math.ceil(len(df_text) / multi_process_count) if multi_process_count > 0 else 1
if chunk_size == 0:
df_text_split = [df_text]
anders:
df_text_split = [df_text[i:i + chunk_size] for i in range(0, len(df_text), chunk_size)]
# mp_result = []
with multiprocessing.Pool(processes=multi_process_count) as pool:
mp_result = pool.map(get_word_list, df_text_split)

df_result = pd.concat(mp_result, ignore_index=True)
# falls 'DB' nicht in df_result.columns enthalten ist:
# df_result['DB'] = ‘
# df_result['Schema'] = ‘
# df_result['Table'] = ‘
# df_result['Column'] = ‘
# df_result['DBSchema'] = ‘

print('[%s] Fertig: Text aus der Word-Datei abrufen.' % get_current_datetime())
# ——————————

print('[%s] Start Get Word Frequency…' % get_current_datetime())
if 'DB' in df_result.columns:
df_group = df_result.groupby('Word').agg({
‘'Wort': 'Anzahl',
‘Source’: lambda x: ‘\n’.join(list(x)[:10]),
‘'DBSchema': 'unique'’
}).rename(columns={
‘'Wort': 'Frequenz',
‘'Quelle': 'Quelle',
‘'DBSchema': 'DBSchema_Freq'’
})
anders:
df_result['DB'] = ‘
df_result['Schema'] = ‘
df_result['Table'] = ‘
df_result['Column'] = ‘
df_result['DBSchema'] = ‘

df_group = df_result.groupby('Word').agg({
‘'Wort': 'Anzahl',
‘Source’: lambda x: ‘\n’.join(list(x)[:10])
}).rename(columns={
‘'Wort': 'Frequenz',
‘'Quelle': 'Quelle'’
})
df_group = df_group.sort_values(by='Freq', ascending=False)
print('[%s] Abruf der Worthäufigkeit abgeschlossen.' % get_current_datetime())
# df_group['Len'] = df_group['Word'].str.len()
# df_group[‘Len’] = df_group[‘Word’].apply(lambda x: len(x))
print('[%s] Starte Wortwolke erstellen…' % get_current_datetime())
now_dt = datetime.datetime.now().strftime(“%Y%m%d%H%M%S”)
make_word_cloud(df_group, now_dt, out_path)
print('[%s] Wortwolke erstellen abgeschlossen.' % get_current_datetime())

print('[%s] Speichern des Extraktionsergebnisses in einer Excel-Datei starten…' % get_current_datetime())
df_result.index += 1
excel_style = {
‘'font-size': '10pt'’
}
df_result = df_result.style.set_properties(**excel_style)
df_group = df_group.style.set_properties(**excel_style)
out_file_name = '%s\\extract_result_%s.xlsx' % (out_path, now_dt) # 'out\\extract_result_%s.xlsx' % now_dt

print('Starte das Schreiben der Excel-Datei…')
mit pd.ExcelWriter(path=out_file_name, engine='xlsxwriter') als writer:
df_result.to_excel(writer,
header=True,
sheet_name='Wortextraktionsergebnis',
index=True,
index_label='Nein',
freeze_panes=(1, 0),
columns=['Word', 'FileName', 'FileType', 'Page', 'Text', 'DB', 'Schema', 'Table', 'Column'])
df_group.to_excel(writer,
header=True,
sheet_name='Worthäufigkeit',
index=True,
index_label='Wort',
freeze_panes=(1, 0))
Arbeitsbuch = writer.book
Arbeitsblatt = writer.sheets['Worthäufigkeit']
wrap_format = workbook.add_format({'text_wrap': True})
worksheet.set_column(“C:C”, None, wrap_format)

# print('Schreiben der Excel-Datei abgeschlossen')
print('[%s] Speichern des Extraktionsergebnisses in Excel-Datei abgeschlossen…' % get_current_datetime())

end_time = time.time()
# verstrichene_Zeit = Endzeit – Startzeit
elapsed_time = str(datetime.timedelta(seconds=end_time – start_time))
drucken('--------------------')
print('[%s] Fertig.' % get_current_datetime())
print('Gesamtzeit: %s' % elapsed_time)
drucken('--------------------')

if __name__ == '__main__':
hauptsächlich()
# print_usage()
# get_db_comment_text('table,column comments.xlsx')