634 lines
22 KiB
Python
634 lines
22 KiB
Python
import argparse
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
from pathlib import Path
|
|
from configparser import RawConfigParser
|
|
from fnmatch import fnmatch
|
|
|
|
import ezdxf
|
|
from openpyxl import Workbook
|
|
|
|
|
|
"""
|
|
Dieses Programm:
|
|
- liest eine DXF Datei und sammelt alle TEXT und MTEXT Objekte
|
|
ODER liest Texte aus einer TXT Datei (ein Text pro Zeile)
|
|
- filtert die Texte basierend auf Mustern in translator.cfg
|
|
- übersetzt optional Texte mit Trigrammen, Bigrammen und Einzelwörtern aus translation/<LANG>.cfg
|
|
- schreibt die Ergebnisse in eine Excel- oder JSON-Datei
|
|
- speichert die Ausgabedatei im PROJECT_WORK Verzeichnis
|
|
"""
|
|
|
|
|
|
def check_environment_var(env_str: str) -> Path:
|
|
"""Prüft ob eine Umgebungsvariable gesetzt ist und gibt den Pfad zurück."""
|
|
out_path = os.environ.get(env_str)
|
|
if out_path:
|
|
return Path(out_path)
|
|
else:
|
|
print(f"Umgebungsvariable {env_str} ist nicht gesetzt oder leer.")
|
|
sys.exit(1)
|
|
|
|
|
|
def load_translation_config(translation_lang: str, translation_dir: Path) -> tuple[dict[str, str], dict[str, str], dict[str, str]]:
|
|
"""
|
|
Lädt eine Übersetzungs-Config-Datei (z.B. CSK.cfg, EN.cfg, FR.cfg).
|
|
|
|
Args:
|
|
translation_lang: Sprach-Code (z.B. "CSK", "EN", "FR")
|
|
translation_dir: Verzeichnis mit Übersetzungs-Configs (aus PROJECT_TRANSLATION)
|
|
|
|
Returns:
|
|
Tuple mit (Trigramme-Dict, Bigramme-Dict, Single-Dict)
|
|
"""
|
|
config_file = translation_dir / f"{translation_lang}.cfg"
|
|
|
|
if not config_file.exists():
|
|
print(f"FEHLER: Übersetzungs-Konfiguration nicht gefunden: {config_file}")
|
|
sys.exit(1)
|
|
|
|
# RawConfigParser mit case-sensitive Keys
|
|
config = RawConfigParser()
|
|
# Überschreibe optionxform um Groß-/Kleinschreibung zu erhalten
|
|
config.optionxform = str
|
|
try:
|
|
config.read(config_file, encoding='utf-8')
|
|
except Exception as e:
|
|
print(f"Fehler beim Lesen der Übersetzungs-Konfiguration: {e}")
|
|
sys.exit(1)
|
|
|
|
trigramme = {}
|
|
bigramme = {}
|
|
single = {}
|
|
|
|
# Lade Trigramme
|
|
if config.has_section('trigramme'):
|
|
for key in config['trigramme']:
|
|
original = key
|
|
translation = config['trigramme'][key]
|
|
if translation and not translation.startswith('#'):
|
|
trigramme[original] = translation
|
|
|
|
# Lade Bigramme
|
|
if config.has_section('bigramme'):
|
|
for key in config['bigramme']:
|
|
original = key
|
|
translation = config['bigramme'][key]
|
|
if translation and not translation.startswith('#'):
|
|
bigramme[original] = translation
|
|
|
|
# Lade Single
|
|
if config.has_section('single'):
|
|
for key in config['single']:
|
|
original = key
|
|
translation = config['single'][key]
|
|
if translation and not translation.startswith('#'):
|
|
single[original] = translation
|
|
|
|
print(f"\nÜbersetzungs-Config geladen ({translation_lang}):")
|
|
print(f" Trigramme: {len(trigramme)}")
|
|
print(f" Bigramme: {len(bigramme)}")
|
|
print(f" Einzelwörter: {len(single)}")
|
|
|
|
return trigramme, bigramme, single
|
|
|
|
|
|
def load_ignore_patterns(cfg_path: Path) -> tuple[list[str], list[str]]:
|
|
"""
|
|
Liest die ignore_pattern aus der translator.cfg Datei.
|
|
Unterstützt sowohl Wildcard-Muster (*,?) als auch reguläre Ausdrücke.
|
|
|
|
Args:
|
|
cfg_path: Pfad zum Konfigurationsverzeichnis (PROJECT_CFG)
|
|
|
|
Returns:
|
|
Tuple mit (Wildcard-Mustern, Regex-Mustern)
|
|
"""
|
|
config_file = cfg_path / "translator.cfg"
|
|
|
|
if not config_file.exists():
|
|
print(f"FEHLER: Konfigurationsdatei nicht gefunden: {config_file}")
|
|
print(f"Bitte erstellen Sie die Datei 'translator.cfg' im Verzeichnis: {cfg_path}")
|
|
sys.exit(1)
|
|
|
|
# RawConfigParser verhindert dass Backslashes in Regex-Mustern escaped werden
|
|
config = RawConfigParser()
|
|
# Überschreibe optionxform um Groß-/Kleinschreibung zu erhalten
|
|
config.optionxform = str
|
|
try:
|
|
config.read(config_file, encoding='utf-8')
|
|
except Exception as e:
|
|
print(f"Fehler beim Lesen der Konfigurationsdatei: {e}")
|
|
sys.exit(1)
|
|
|
|
wildcard_patterns = []
|
|
regex_patterns = []
|
|
|
|
# Lade Wildcard-Muster
|
|
if config.has_section('ignore_pattern_wildcard'):
|
|
for key in config['ignore_pattern_wildcard']:
|
|
pattern = config['ignore_pattern_wildcard'][key].strip()
|
|
if pattern and not pattern.startswith('#'):
|
|
wildcard_patterns.append(pattern)
|
|
|
|
# Lade Regex-Muster
|
|
if config.has_section('ignore_pattern_regex'):
|
|
for key in config['ignore_pattern_regex']:
|
|
pattern = config['ignore_pattern_regex'][key].strip()
|
|
if pattern and not pattern.startswith('#'):
|
|
regex_patterns.append(pattern)
|
|
|
|
print(f"Geladene Wildcard-Muster: {len(wildcard_patterns)}")
|
|
for pattern in wildcard_patterns:
|
|
print(f" - {pattern}")
|
|
|
|
print(f"Geladene Regex-Muster: {len(regex_patterns)}")
|
|
for pattern in regex_patterns:
|
|
print(f" - {pattern}")
|
|
|
|
return wildcard_patterns, regex_patterns
|
|
|
|
|
|
def translate_text(text: str, trigramme: dict[str, str], bigramme: dict[str, str], single: dict[str, str]) -> str:
|
|
"""
|
|
Übersetzt einen Text durch Ersetzen von Trigrammen, Bigrammen und Einzelwörtern.
|
|
Ersetzungen erfolgen in dieser Reihenfolge: Trigramme → Bigramme → Einzelwörter.
|
|
|
|
Bei Einzelwörtern werden auch Satzzeichen berücksichtigt:
|
|
- "Weight:" wird zu "Hmotnost:" (Doppelpunkt bleibt erhalten)
|
|
- "(Sub-distributor)" wird zu "(Rozvaděč)" (Klammern bleiben erhalten)
|
|
Bindestriche im Wort (wie "Sub-distributor") bleiben Teil des Kern-Worts.
|
|
|
|
Args:
|
|
text: Zu übersetzender Text
|
|
trigramme: Dictionary mit Drei-Wort-Phrasen
|
|
bigramme: Dictionary mit Zwei-Wort-Phrasen
|
|
single: Dictionary mit Einzelwörtern
|
|
|
|
Returns:
|
|
Übersetzter Text (leer wenn keine Übersetzung gefunden wurde)
|
|
"""
|
|
translated_text = text
|
|
has_translation = False
|
|
|
|
# 1. Trigramme ersetzen (längste Phrasen zuerst)
|
|
for original, translation in trigramme.items():
|
|
if original in translated_text:
|
|
translated_text = translated_text.replace(original, translation)
|
|
has_translation = True
|
|
|
|
# 2. Bigramme ersetzen
|
|
for original, translation in bigramme.items():
|
|
if original in translated_text:
|
|
translated_text = translated_text.replace(original, translation)
|
|
has_translation = True
|
|
|
|
# 3. Einzelwörter ersetzen
|
|
words = translated_text.split()
|
|
translated_words = []
|
|
for word in words:
|
|
if word in single:
|
|
# Direkter Match
|
|
translated_words.append(single[word])
|
|
has_translation = True
|
|
else:
|
|
# Prüfe ob Wort mit Satzzeichen am Ende existiert (z.B. "Weight:" -> "Weight")
|
|
# Trenne Satzzeichen am Anfang und Ende vom Kern-Wort
|
|
# Kern-Wort kann Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten
|
|
match = re.match(r'^([^\w-]*)([\w-]+)([^\w-]*)$', word)
|
|
if match:
|
|
prefix, core_word, suffix = match.groups()
|
|
if core_word in single:
|
|
# Übersetze Kern-Wort und behalte Satzzeichen
|
|
translated_words.append(prefix + single[core_word] + suffix)
|
|
has_translation = True
|
|
else:
|
|
translated_words.append(word)
|
|
else:
|
|
translated_words.append(word)
|
|
translated_text = ' '.join(translated_words)
|
|
|
|
# Gib nur übersetzten Text zurück wenn tatsächlich etwas übersetzt wurde
|
|
return translated_text if has_translation else ""
|
|
|
|
|
|
def should_ignore_text(text: str, wildcard_patterns: list[str], regex_patterns: list[str], debug: bool = False) -> bool:
|
|
"""
|
|
Prüft ob ein Text ignoriert werden soll basierend auf den Mustern.
|
|
|
|
Args:
|
|
text: Zu prüfender Text
|
|
wildcard_patterns: Liste der Wildcard-Muster (*,?)
|
|
regex_patterns: Liste der regulären Ausdrücke
|
|
debug: Wenn True, gibt Debug-Informationen aus
|
|
|
|
Returns:
|
|
True wenn Text ignoriert werden soll, False sonst
|
|
"""
|
|
# Prüfe Wildcard-Muster
|
|
for pattern in wildcard_patterns:
|
|
if fnmatch(text, pattern):
|
|
if debug:
|
|
print(f" DEBUG: '{text}' matched wildcard '{pattern}'")
|
|
return True
|
|
|
|
# Prüfe Regex-Muster
|
|
for pattern in regex_patterns:
|
|
try:
|
|
if re.search(pattern, text):
|
|
if debug:
|
|
print(f" DEBUG: '{text}' matched regex '{pattern}'")
|
|
return True
|
|
except re.error:
|
|
# Falls ungültiger Regex, ignoriere dieses Muster
|
|
print(f"WARNUNG: Ungültiger regulärer Ausdruck: {pattern}")
|
|
continue
|
|
|
|
return False
|
|
|
|
|
|
def extract_text_from_dxf(filename: Path) -> list[str]:
|
|
"""
|
|
Extrahiert alle TEXT und MTEXT Objekte aus einer DXF Datei.
|
|
Verwendet ein Set, um Duplikate zu vermeiden.
|
|
Filtert leere Texte heraus.
|
|
|
|
Args:
|
|
filename: Pfad zur DXF Datei
|
|
|
|
Returns:
|
|
Alphabetisch sortierte Liste aller gefundenen Texte (ohne Duplikate, ohne leere Texte)
|
|
"""
|
|
texts_set = set() # Set für eindeutige Texte
|
|
total_count = 0
|
|
empty_count = 0
|
|
|
|
try:
|
|
doc = ezdxf.readfile(filename)
|
|
msp = doc.modelspace()
|
|
|
|
# Sammle alle TEXT Objekte
|
|
for entity in msp.query('TEXT'):
|
|
if entity.dxf.text:
|
|
total_count += 1
|
|
text = entity.dxf.text.strip() # Entferne führende/nachfolgende Leerzeichen
|
|
|
|
# Ignoriere leere Texte
|
|
if not text:
|
|
empty_count += 1
|
|
continue
|
|
|
|
texts_set.add(text)
|
|
|
|
# Sammle alle MTEXT Objekte
|
|
for entity in msp.query('MTEXT'):
|
|
if entity.text:
|
|
total_count += 1
|
|
text = entity.text.strip() # Entferne führende/nachfolgende Leerzeichen
|
|
|
|
# Ignoriere leere Texte
|
|
if not text:
|
|
empty_count += 1
|
|
continue
|
|
|
|
texts_set.add(text)
|
|
|
|
# Konvertiere Set zu sortierter Liste
|
|
texts = sorted(texts_set)
|
|
|
|
print(f"Anzahl gefundener TEXT/MTEXT Objekte: {total_count}")
|
|
print(f"Leere Texte ignoriert: {empty_count}")
|
|
print(f"Duplikate entfernt: {total_count - empty_count - len(texts)}")
|
|
print(f"Eindeutige Texte extrahiert: {len(texts)}")
|
|
|
|
except Exception as e:
|
|
print(f"Fehler beim Lesen der DXF Datei: {e}")
|
|
sys.exit(1)
|
|
|
|
return texts
|
|
|
|
|
|
def filter_texts(texts: list[str], wildcard_patterns: list[str], regex_patterns: list[str], debug: bool = False) -> tuple[list[str], list[str]]:
|
|
"""
|
|
Filtert eine Liste von Texten basierend auf Wildcard- und Regex-Mustern.
|
|
Diese Funktion ist unabhängig von der Quelle der Texte (DXF oder TXT).
|
|
|
|
Args:
|
|
texts: Liste der zu filternden Texte
|
|
wildcard_patterns: Liste der Wildcard-Muster zum Filtern
|
|
regex_patterns: Liste der Regex-Muster zum Filtern
|
|
debug: Wenn True, gibt Debug-Informationen aus
|
|
|
|
Returns:
|
|
Tuple mit (akzeptierte Texte, ignorierte Texte) - beide alphabetisch sortiert
|
|
"""
|
|
accepted_texts = []
|
|
ignored_texts = []
|
|
|
|
for text in texts:
|
|
if should_ignore_text(text, wildcard_patterns, regex_patterns, debug):
|
|
ignored_texts.append(text)
|
|
else:
|
|
accepted_texts.append(text)
|
|
|
|
# Sortiere beide Listen alphabetisch
|
|
accepted_texts.sort()
|
|
ignored_texts.sort()
|
|
|
|
print(f"\nFilterung abgeschlossen:")
|
|
print(f" Akzeptierte Texte: {len(accepted_texts)}")
|
|
print(f" Ignorierte Texte: {len(ignored_texts)}")
|
|
|
|
return accepted_texts, ignored_texts
|
|
|
|
|
|
def read_texts_from_file(filename: Path) -> list[str]:
|
|
"""
|
|
Liest Texte aus einer UTF-8 Textdatei (ein Text pro Zeile).
|
|
Entfernt Duplikate und leere Zeilen.
|
|
|
|
Args:
|
|
filename: Pfad zur Textdatei
|
|
|
|
Returns:
|
|
Alphabetisch sortierte Liste aller Texte (ohne Duplikate, ohne leere Zeilen)
|
|
"""
|
|
texts_set = set()
|
|
|
|
try:
|
|
with open(filename, 'r', encoding='utf-8') as f:
|
|
for line in f:
|
|
text = line.strip()
|
|
if text: # Ignoriere leere Zeilen
|
|
# Konvertiere escaped Zeilenumbrüche zurück
|
|
text = text.replace('\\n', '\n').replace('\\r', '\r')
|
|
texts_set.add(text)
|
|
|
|
texts = sorted(texts_set)
|
|
print(f"Texte aus Datei gelesen: {len(texts)}")
|
|
return texts
|
|
|
|
except Exception as e:
|
|
print(f"Fehler beim Lesen der Textdatei: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def write_texts_to_excel(texts: list[str], output_path: Path,
|
|
translation_dicts: tuple[dict[str, str], dict[str, str], dict[str, str]] = None):
|
|
"""
|
|
Schreibt die Texte in die erste Spalte einer Excel-Datei.
|
|
Optional: Schreibt Übersetzungen in die zweite Spalte.
|
|
|
|
Args:
|
|
texts: Liste der zu schreibenden Texte
|
|
output_path: Pfad zur Ausgabe-Excel-Datei
|
|
translation_dicts: Optional: Tuple mit (Trigramme, Bigramme, Single) für Übersetzungen
|
|
"""
|
|
wb = Workbook()
|
|
ws = wb.active
|
|
ws.title = "Texte"
|
|
|
|
# Kopfzeile
|
|
ws['A1'] = "Text"
|
|
if translation_dicts:
|
|
ws['B1'] = "Übersetzung"
|
|
|
|
# Texte schreiben
|
|
for idx, text in enumerate(texts, start=2):
|
|
ws[f'A{idx}'] = text
|
|
|
|
# Optional: Übersetzung in zweite Spalte
|
|
if translation_dicts:
|
|
trigramme, bigramme, single = translation_dicts
|
|
translated = translate_text(text, trigramme, bigramme, single)
|
|
if translated: # Nur wenn Übersetzung gefunden wurde
|
|
ws[f'B{idx}'] = translated
|
|
# Sonst bleibt die Zelle leer
|
|
|
|
# Spaltenbreiten anpassen
|
|
ws.column_dimensions['A'].width = 50
|
|
if translation_dicts:
|
|
ws.column_dimensions['B'].width = 50
|
|
|
|
try:
|
|
wb.save(output_path)
|
|
print(f"Excel-Datei erfolgreich erstellt: {output_path}")
|
|
if translation_dicts:
|
|
print(f" Mit Übersetzungen in Spalte B")
|
|
except Exception as e:
|
|
print(f"Fehler beim Schreiben der Excel-Datei: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
def write_texts_to_json(texts: list[str], ignored_texts: list[str], output_path: Path,
|
|
translation_dicts: tuple[dict[str, str], dict[str, str], dict[str, str]] = None):
|
|
"""
|
|
Schreibt die Texte in eine JSON-Datei mit drei Blöcken.
|
|
|
|
Args:
|
|
texts: Liste der akzeptierten Texte
|
|
ignored_texts: Liste der ignorierten Texte
|
|
output_path: Pfad zur Ausgabe-JSON-Datei
|
|
translation_dicts: Optional: Tuple mit (Trigramme, Bigramme, Single) für Übersetzungen
|
|
"""
|
|
output_data = {}
|
|
|
|
# Block 1: Übersetzte Texte (als Liste von Dicts mit source/target)
|
|
# Block 2: Nicht übersetzte Texte (nur akzeptierte Texte ohne Übersetzung)
|
|
if translation_dicts:
|
|
trigramme, bigramme, single = translation_dicts
|
|
translations = []
|
|
untranslated_texts = []
|
|
|
|
for text in texts:
|
|
translated = translate_text(text, trigramme, bigramme, single)
|
|
if translated: # Übersetzung vorhanden
|
|
translations.append({
|
|
"source": text,
|
|
"target": translated
|
|
})
|
|
else: # Keine Übersetzung vorhanden
|
|
untranslated_texts.append(text)
|
|
|
|
output_data["translations"] = translations
|
|
output_data["texts"] = untranslated_texts
|
|
else:
|
|
# Ohne Übersetzungs-Config: alle akzeptierten Texte sind nicht übersetzt
|
|
output_data["translations"] = []
|
|
output_data["texts"] = texts
|
|
|
|
# Block 3: Ignorierte Texte (als Liste)
|
|
output_data["ignored"] = ignored_texts
|
|
|
|
try:
|
|
with open(output_path, 'w', encoding='utf-8') as f:
|
|
json.dump(output_data, f, ensure_ascii=False, indent=2)
|
|
|
|
print(f"JSON-Datei erfolgreich erstellt: {output_path}")
|
|
if translation_dicts:
|
|
print(f" Übersetzungen: {len(output_data['translations'])}")
|
|
print(f" Nicht übersetzte Texte: {len(output_data['texts'])}")
|
|
else:
|
|
print(f" Akzeptierte Texte: {len(output_data['texts'])}")
|
|
print(f" Ignorierte Texte: {len(ignored_texts)}")
|
|
except Exception as e:
|
|
print(f"Fehler beim Schreiben der JSON-Datei: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser(
|
|
description='Extrahiert TEXT und MTEXT Objekte aus einer DXF Datei oder filtert Texte aus einer TXT Datei. Optional mit Übersetzungsfunktion.',
|
|
prog='translate'
|
|
)
|
|
|
|
# Mutually exclusive group: entweder DXF-Extraktion oder TXT-Filterung
|
|
input_group = parser.add_mutually_exclusive_group(required=True)
|
|
input_group.add_argument(
|
|
'-e', '--extract',
|
|
action='store_true',
|
|
help='Extrahiert Texte aus DXF/DWG Datei (benötigt --filename)'
|
|
)
|
|
input_group.add_argument(
|
|
'--fromtxt',
|
|
action='store',
|
|
metavar='FILE.txt',
|
|
help='Filtert Texte aus einer TXT Datei (ein Text pro Zeile)'
|
|
)
|
|
|
|
parser.add_argument(
|
|
'-f', '--filename',
|
|
action='store',
|
|
help='DXF/DWG Datei (.dxf, .dwg) die verarbeitet werden soll (nur mit --extract)',
|
|
metavar='myfile.dxf'
|
|
)
|
|
parser.add_argument(
|
|
'-o', '--outname',
|
|
action='store',
|
|
help='Name der Ausgabedatei (ohne Pfad, mit oder ohne .xlsx/.txt Endung)',
|
|
metavar='output.xlsx'
|
|
)
|
|
parser.add_argument(
|
|
'-d', '--debug',
|
|
action='store_true',
|
|
help='Aktiviert Debug-Ausgabe für Pattern-Matching'
|
|
)
|
|
parser.add_argument(
|
|
'-t', '--export-type',
|
|
action='store',
|
|
default='excel',
|
|
choices=['excel', 'json'],
|
|
help='Exportformat: excel (Standard) oder json (JSON-Datei)'
|
|
)
|
|
parser.add_argument(
|
|
'--translate',
|
|
action='store',
|
|
metavar='LANG',
|
|
help='Übersetzt Texte mit Config aus translation/<LANG>.cfg (z.B. CSK, EN, FR)'
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Validierung: --extract benötigt --filename
|
|
if args.extract and not args.filename:
|
|
parser.error("--extract benötigt --filename")
|
|
|
|
# Validierung: --filename nur mit --extract
|
|
if args.filename and not args.extract:
|
|
parser.error("--filename kann nur mit --extract verwendet werden")
|
|
|
|
# Prüfe Umgebungsvariablen
|
|
work_dir = check_environment_var('PROJECT_WORK')
|
|
cfg_dir = check_environment_var('PROJECT_CFG')
|
|
|
|
# Lade Ignore-Muster aus Konfigurationsdatei
|
|
wildcard_patterns, regex_patterns = load_ignore_patterns(cfg_dir)
|
|
|
|
# Optional: Lade Übersetzungs-Config
|
|
translation_dicts = None
|
|
if args.translate:
|
|
translation_dir = check_environment_var('PROJECT_TRANSLATION')
|
|
translation_dicts = load_translation_config(args.translate, translation_dir)
|
|
|
|
if args.debug:
|
|
print("DEBUG-Modus aktiviert")
|
|
|
|
# Bestimme Input-Modus und Datei
|
|
if args.extract:
|
|
# DXF/DWG-Modus
|
|
input_filename = args.filename
|
|
file_extension = input_filename.lower()
|
|
|
|
if not file_extension.endswith(('.dxf', '.dwg')):
|
|
print("Mit --extract nur .dxf oder .dwg Dateien erlaubt")
|
|
sys.exit(1)
|
|
|
|
# Versuche zuerst Datei im Work-Ordner zu finden
|
|
filename = work_dir / input_filename
|
|
if not filename.exists():
|
|
# Falls nicht gefunden, prüfe ob es ein vollständiger Pfad ist
|
|
filename = Path(input_filename)
|
|
if not filename.exists():
|
|
print(f"Datei nicht gefunden: {input_filename}")
|
|
print(f" Geprüft in Work-Ordner: {work_dir / input_filename}")
|
|
print(f" Geprüft als vollständiger Pfad: {filename}")
|
|
sys.exit(1)
|
|
|
|
print(f"Lese DXF Datei: {filename}")
|
|
all_texts = extract_text_from_dxf(filename)
|
|
|
|
else: # args.fromtxt
|
|
# TXT-Modus
|
|
input_filename = args.fromtxt
|
|
|
|
if not input_filename.lower().endswith('.txt'):
|
|
print("Mit --fromtxt nur .txt Dateien erlaubt")
|
|
sys.exit(1)
|
|
|
|
# Versuche zuerst Datei im Work-Ordner zu finden
|
|
filename = work_dir / input_filename
|
|
if not filename.exists():
|
|
# Falls nicht gefunden, prüfe ob es ein vollständiger Pfad ist
|
|
filename = Path(input_filename)
|
|
if not filename.exists():
|
|
print(f"Datei nicht gefunden: {input_filename}")
|
|
print(f" Geprüft in Work-Ordner: {work_dir / input_filename}")
|
|
print(f" Geprüft als vollständiger Pfad: {filename}")
|
|
sys.exit(1)
|
|
|
|
print(f"Lese Textdatei: {filename}")
|
|
all_texts = read_texts_from_file(filename)
|
|
|
|
# Schritt 2: Texte filtern
|
|
texts, ignored_texts = filter_texts(all_texts, wildcard_patterns, regex_patterns, args.debug)
|
|
|
|
# Erstelle Output-Dateinamen basierend auf Export-Typ
|
|
if args.outname:
|
|
# Verwende benutzerdefinierten Namen
|
|
output_filename = args.outname
|
|
# Füge Endung hinzu falls nicht vorhanden
|
|
if args.export_type == 'excel':
|
|
if not output_filename.endswith('.xlsx'):
|
|
output_filename += '.xlsx'
|
|
else: # json
|
|
if not output_filename.endswith('.json'):
|
|
output_filename += '.json'
|
|
else:
|
|
# Standardname basierend auf Eingabedatei
|
|
if args.export_type == 'excel':
|
|
output_filename = filename.stem + "_texts.xlsx"
|
|
else: # json
|
|
output_filename = filename.stem + "_texts.json"
|
|
|
|
output_path = work_dir / output_filename
|
|
|
|
# Schreibe Texte in gewähltem Format
|
|
if args.export_type == 'excel':
|
|
write_texts_to_excel(texts, output_path, translation_dicts)
|
|
else: # json
|
|
write_texts_to_json(texts, ignored_texts, output_path, translation_dicts)
|
|
|
|
print("Verarbeitung erfolgreich abgeschlossen.")
|