euer-datev 0.1.0__py3-none-any.whl

euer_datev/__init__.py

@@ -0,0 +1,10 @@
+"""euer-datev: Offizieller DATEV-Export (EXTF 700) & Kanzlei-Schnittstelle für euer.
+
+Ermöglicht den dateibasierten 1-Klick-Export von Buchungsdaten und Belegen
+im offiziellen DATEV-Format zur nahtlosen Übernahme in DATEV Kanzlei-Rechnungswesen.
+"""
+
+VERSION = "0.1.0"
+__version__ = VERSION
+
+__all__ = ["VERSION", "__version__"]

euer_datev/cli.py

@@ -0,0 +1,419 @@
+"""Standalone CLI Interface für euer-datev."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import VERSION
+from .config import generate_default_skr_template, load_datev_config
+from .constants import DEFAULT_BERATER_NUMMER, DEFAULT_MANDANTEN_NUMMER
+from .exporter import write_extf_csv_file
+from .license import save_license_token, verify_license
+from .mapping import assign_unique_beleglinks, map_transaction_to_datev
+from .packager import package_datev_export
+from .reader import get_db_connection, read_transactions_from_db
+from .validator import validate_bookings
+
+if sys.platform == "win32":
+    try:
+        if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+
+def _safe_print(*args, **kwargs) -> None:
+    """Sicheres print für Plattformen mit eingeschränktem Konsolen-Encoding (z. B. Windows cp1252)."""
+    file = kwargs.get("file") or sys.stdout
+    sep = kwargs.get("sep", " ")
+    end = kwargs.get("end", "\n")
+    text = sep.join(str(a) for a in args) + end
+    try:
+        file.write(text)
+        file.flush()
+    except (UnicodeEncodeError, AttributeError):
+        encoding = getattr(file, "encoding", None) or "ascii"
+        sanitized = text.encode(encoding, errors="replace").decode(encoding)
+        file.write(sanitized)
+        file.flush()
+
+
+print = _safe_print
+
+
+def find_default_db_path() -> Path:
+    """Sucht nach der standardmaessigen euer.db."""
+    local_db = Path.cwd() / ".euer" / "euer.db"
+    if local_db.is_file():
+        return local_db
+
+    local_root_db = Path.cwd() / "euer.db"
+    if local_root_db.is_file():
+        return local_root_db
+
+    home_db = Path.home() / ".config" / "euer" / "euer.db"
+    return home_db
+
+
+def cmd_export(args: argparse.Namespace) -> int:
+    """Fuehrt den DATEV-Export durch."""
+    db_path = Path(args.db) if args.db else find_default_db_path()
+    if not db_path.is_file():
+        print(f"Fehler: Datenbank '{db_path}' nicht gefunden.", file=sys.stderr)
+        return 1
+
+    config = load_datev_config(
+        config_path=args.config,
+        override_year=args.year,
+        override_skr=args.skr,
+        override_berater=args.berater,
+        override_mandant=args.mandant,
+    )
+
+    try:
+        conn = get_db_connection(db_path)
+    except Exception as exc:
+        print(f"Fehler beim Verbinden mit der Datenbank: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        raw_txs = read_transactions_from_db(
+            conn=conn,
+            year=args.year,
+            month=args.month,
+            quarter=args.quarter,
+            from_date=args.from_date,
+            to_date=args.to_date,
+        )
+    finally:
+        conn.close()
+
+    if not raw_txs:
+        print("Hinweis: Keine Buchungen im angegebenen Zeitraum gefunden.", file=sys.stderr)
+        return 0
+
+    # Tatsächliche Buchungsjahre aus den Transaktionen ermitteln
+    years_in_tx = sorted({int(tx.date[:4]) for tx in raw_txs if tx.date and len(tx.date) >= 4})
+    if not years_in_tx:
+        print("Fehler: Buchungsdaten enthalten kein gültiges Buchungsdatum.", file=sys.stderr)
+        return 1
+
+    # Dynamische Erkennung des Wirtschaftsjahres falls kein --year angegeben wurde
+    if not args.year and len(years_in_tx) == 1:
+        detected_year = years_in_tx[0]
+        config.wirtschaftsjahr_beginn = f"{detected_year}0101"
+
+    # Lizenzprüfung gegen jedes tatsächlich in den Buchungen vorkommende Steuerjahr
+    # Verhindert jede Umgehung durch Weglassen von --year (z. B. via --from-date / --to-date)
+    for yr in years_in_tx:
+        lic = verify_license(target_year=yr)
+        if not lic.is_valid:
+            print(f"❌ Lizenzfehler: {lic.message}", file=sys.stderr)
+            return 1
+
+    # Evaluierungs-Modus: Beschränkung auf maximal 5 Buchungssätze zur Probe
+    lic_status = verify_license(target_year=years_in_tx[0])
+    if lic_status.is_evaluation:
+        max_eval_bookings = 5
+        if len(raw_txs) > max_eval_bookings:
+            print(
+                f"\n❌ Evaluierungs-Modus: Im Evaluierungsmodus können maximal {max_eval_bookings} "
+                f"Buchungssätze zur Probe exportiert werden (gefunden: {len(raw_txs)}).\n"
+                f"   Für den vollständigen Export des Steuerjahres {years_in_tx[0]} aktiviere bitte eine Lizenz:\n\n"
+                f"   euer datev license activate <DEIN-LIZENZSCHLÜSSEL>\n\n"
+                f"   Lizenzen erwerben unter: https://euer-buchhaltung.de/datev\n",
+                file=sys.stderr,
+            )
+            return 1
+        else:
+            print(
+                f"⚠️  PROBE-EXPORT (Evaluierungs-Modus: {len(raw_txs)}/{max_eval_bookings} Buchungssätze).\n"
+                f"   Für den vollständigen Jahresabschluss bitte Lizenz aktivieren: https://euer-buchhaltung.de/datev\n",
+                file=sys.stderr,
+            )
+
+    # Transformation in DATEV-Buchungssätze
+    bookings = [map_transaction_to_datev(tx, config) for tx in raw_txs]
+    assign_unique_beleglinks(bookings)
+
+    # Validierung
+    val_res = validate_bookings(bookings, config)
+    if not val_res.is_valid and not args.force:
+        print("\nFehler bei der Vorab-Prüfung des DATEV-Exports:", file=sys.stderr)
+        for issue in val_res.issues:
+            if issue.severity == "ERROR":
+                print(f"  ❌ [{issue.code}] {issue.message}", file=sys.stderr)
+        print(
+            "\nExport abgebrochen. Behebe die Fehler oder nutze '--force' zum Erzwingen.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # Zeitraum ermitteln
+    all_dates = [tx.date[:10].replace("-", "") for tx in raw_txs if tx.date]
+    min_date = min(all_dates) if all_dates else f"{args.year or 2026}0101"
+    max_date = max(all_dates) if all_dates else f"{args.year or 2026}1231"
+
+    # Ausgabepfad festlegen
+    export_fmt = getattr(args, "format", "zip")
+    year_str = str(args.year) if args.year else config.wirtschaftsjahr_beginn[:4]
+    suffix = f"_{year_str}"
+    if args.quarter:
+        suffix += f"_Q{args.quarter}"
+    elif args.month:
+        suffix += f"_M{args.month:02d}"
+
+    if args.output:
+        out_path = Path(args.output)
+        if out_path.is_dir() or (not out_path.suffix and not out_path.exists()):
+            out_path.mkdir(parents=True, exist_ok=True)
+            filename = f"DATEV_EXTF{suffix}.{export_fmt}"
+            target_path = out_path / filename
+        else:
+            target_path = out_path
+    else:
+        out_dir = config.export_dir or (Path.cwd() / "exports")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        target_path = out_dir / f"DATEV_EXTF{suffix}.{export_fmt}"
+
+    # Export ausfuehren
+    if export_fmt == "csv":
+        write_extf_csv_file(
+            target_path=target_path,
+            bookings=bookings,
+            config=config,
+            date_from=min_date,
+            date_to=max_date,
+        )
+        print(f"✅ DATEV EXTF-700 CSV erfolgreich exportiert: {target_path}")
+    else:
+        res = package_datev_export(
+            target_zip_path=target_path,
+            bookings=bookings,
+            config=config,
+            date_from=min_date,
+            date_to=max_date,
+            validation_result=val_res,
+        )
+        if not val_res.is_valid and not args.force:
+            print(
+                f"Exportpaket {target_path} enthält Fehler beim Verpacken der Belege. "
+                "Siehe PRUEFPROTOKOLL.txt im Archiv.",
+                file=sys.stderr,
+            )
+            return 1
+        print(f"✅ DATEV-Exportpaket erfolgreich erstellt: {res.zip_path}")
+        print(f"   • {res.total_bookings} Buchungssätze ({res.total_volume_eur:,.2f} EUR)")
+        print(f"   • {res.total_receipts_packaged} Belege im Archiv abgelegt (Beleglink-Referenz)")
+        if res.missing_receipts_count > 0:
+            print(
+                f"   ⚠️ {res.missing_receipts_count} Belegdateien nicht gefunden (Details in PRÜFPROTOKOLL.txt)"
+            )
+
+    if val_res.warning_count > 0:
+        print(f"   ℹ️ {val_res.warning_count} Warnungen bei der Validierung aufgetreten.")
+
+    return 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    """Prueft die Buchungsdaten auf DATEV-Konformitaet ohne Datei zu schreiben."""
+    db_path = Path(args.db) if args.db else find_default_db_path()
+    if not db_path.is_file():
+        print(f"Fehler: Datenbank '{db_path}' nicht gefunden.", file=sys.stderr)
+        return 1
+
+    config = load_datev_config(
+        config_path=args.config,
+        override_year=args.year,
+        override_skr=args.skr,
+    )
+
+    try:
+        conn = get_db_connection(db_path)
+    except Exception as exc:
+        print(f"Fehler beim Verbinden mit der Datenbank: {exc}", file=sys.stderr)
+        return 1
+
+    try:
+        raw_txs = read_transactions_from_db(conn=conn, year=args.year)
+    finally:
+        conn.close()
+
+    if not raw_txs:
+        print("Keine Buchungen gefunden.", file=sys.stderr)
+        return 0
+
+    if not args.year:
+        years_in_tx = {tx.date[:4] for tx in raw_txs if tx.date and len(tx.date) >= 4}
+        if len(years_in_tx) == 1:
+            detected_year = list(years_in_tx)[0]
+            config.wirtschaftsjahr_beginn = f"{detected_year}0101"
+
+    bookings = [map_transaction_to_datev(tx, config) for tx in raw_txs]
+    assign_unique_beleglinks(bookings)
+    val_res = validate_bookings(bookings, config)
+
+    print(f"\nDATEV-Validierungsbericht für SKR {config.skr} ({len(bookings)} Buchungen):")
+    print(f"  Fehler (ERROR):   {val_res.error_count}")
+    print(f"  Warnungen (WARN): {val_res.warning_count}")
+    print(f"  Hinweise (INFO):  {val_res.info_count}\n")
+
+    for issue in val_res.issues:
+        icon = "❌" if issue.severity == "ERROR" else ("⚠️" if issue.severity == "WARNING" else "ℹ️")
+        print(f"  {icon} [{issue.severity}] {issue.message}")
+
+    if not val_res.is_valid:
+        print("\n❌ Validierung fehlgeschlagen: Behebe die Fehler vor dem Export.", file=sys.stderr)
+        return 1
+
+    print("\n✅ Validierung erfolgreich: Buchungsstapel ist bereit für DATEV.")
+    return 0
+
+
+def cmd_init_skr(args: argparse.Namespace) -> int:
+    """Gibt empfohlene Konfigurations-Templates für SKR03 oder SKR04 aus."""
+    template = generate_default_skr_template(skr=args.skr)
+    if args.write:
+        target = Path(args.write)
+        if target.is_file():
+            content = target.read_text(encoding="utf-8")
+            content += "\n\n" + template
+            target.write_text(content, encoding="utf-8")
+            print(f"✅ SKR-{args.skr}-Vorlage an {target} angehängt.")
+        else:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(template, encoding="utf-8")
+            print(f"✅ SKR-{args.skr}-Vorlage in neue Datei {target} geschrieben.")
+    else:
+        print(template)
+    return 0
+
+
+def cmd_license(args: argparse.Namespace) -> int:
+    """Verwaltet den Lizenzschlüssel."""
+    if args.action == "status":
+        status = verify_license()
+        print("\neuer-datev Lizenzstatus:")
+        print(f"  Gültig:       {'Ja' if status.is_valid else 'Nein'}")
+        print(f"  Lizenztyp:    {status.tier.capitalize()}")
+        print(f"  Lizenznehmer: {status.licensee}")
+        if status.allowed_years:
+            print(f"  Steuerjahr:   {', '.join(str(y) for y in status.allowed_years)}")
+        elif status.tier in ("kanzlei", "pro"):
+            print("  Steuerjahr:   Alle (Kanzlei-Lizenz)")
+        if status.active_tokens_count > 0:
+            print(f"  Lizenzen:     {status.active_tokens_count} aktiv hinterlegt")
+        print(f"  Details:      {status.message}\n")
+        return 0 if status.is_valid else 1
+    elif args.action == "activate":
+        if not args.key:
+            print(
+                "Fehler: Lizenzschlüssel erforderlich (z. B. euer datev license activate <SCHLÜSSEL>).",
+                file=sys.stderr,
+            )
+            return 1
+        clean_key = args.key.strip()
+        try:
+            path, status = save_license_token(clean_key)
+            print(f"✅ Lizenz erfolgreich aktiviert und hinzugefügt in: {path}")
+            print(f"   Lizenznehmer: {status.licensee}")
+            if status.allowed_years:
+                print(
+                    f"   Freigeschaltete Steuerjahre: {', '.join(str(y) for y in status.allowed_years)}"
+                )
+            else:
+                print("   Freigeschaltete Steuerjahre: Alle (Kanzlei-Lizenz)")
+            return 0
+        except ValueError as exc:
+            print(f"❌ Ungültiger Lizenzschlüssel: {exc}", file=sys.stderr)
+            return 1
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Baut den Standalone-Kommandozeilen-Parser."""
+    parser = argparse.ArgumentParser(
+        prog="euer-datev",
+        description="euer-datev: Offizieller DATEV-Export (EXTF 700) für euer Buchhaltung",
+    )
+    parser.add_argument("--version", action="version", version=f"euer-datev {VERSION}")
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Subcommand: export
+    p_export = subparsers.add_parser("export", help="Exportiert Buchungsdaten im DATEV-Format")
+    p_export.add_argument("--db", help="Pfad zur euer.db")
+    p_export.add_argument("--config", help="Pfad zur config.toml")
+    p_export.add_argument("--year", type=int, help="Steuerjahr filtern (z. B. 2026)")
+    p_export.add_argument("--month", type=int, choices=range(1, 13), help="Monat filtern (1-12)")
+    p_export.add_argument("--quarter", type=int, choices=[1, 2, 3, 4], help="Quartal filtern (1-4)")
+    p_export.add_argument("--from-date", help="Von Datum (YYYY-MM-DD)")
+    p_export.add_argument("--to-date", help="Bis Datum (YYYY-MM-DD)")
+    p_export.add_argument(
+        "--skr", choices=["03", "04"], default=None, help="Kontenrahmen SKR 03 oder SKR 04"
+    )
+    p_export.add_argument(
+        "--berater", default=None, help=f"Beraternummer (default: {DEFAULT_BERATER_NUMMER})"
+    )
+    p_export.add_argument(
+        "--mandant", default=None, help=f"Mandantennummer (default: {DEFAULT_MANDANTEN_NUMMER})"
+    )
+    p_export.add_argument(
+        "--format",
+        choices=["zip", "csv"],
+        default="zip",
+        help="Ausgabeformat: zip (inkl. Belegen) oder csv",
+    )
+    p_export.add_argument("-o", "--output", help="Ausgabedatei oder Zielverzeichnis")
+    p_export.add_argument(
+        "--force", action="store_true", help="Export trotz Validierungsfehlern erzwingen"
+    )
+    p_export.set_defaults(func=cmd_export)
+
+    # Subcommand: validate
+    p_validate = subparsers.add_parser(
+        "validate", help="Prueft Daten auf DATEV-Konformitaet ohne Export"
+    )
+    p_validate.add_argument("--db", help="Pfad zur euer.db")
+    p_validate.add_argument("--config", help="Pfad zur config.toml")
+    p_validate.add_argument("--year", type=int, help="Steuerjahr filtern (z. B. 2026)")
+    p_validate.add_argument(
+        "--skr", choices=["03", "04"], default=None, help="Kontenrahmen SKR 03 oder SKR 04"
+    )
+    p_validate.set_defaults(func=cmd_validate)
+
+    # Subcommand: init-skr
+    p_init = subparsers.add_parser("init-skr", help="Erzeugt TOML-Vorlage für SKR 03 oder SKR 04")
+    p_init.add_argument(
+        "--skr", choices=["03", "04"], default="03", help="Kontenrahmen wählen (default: 03)"
+    )
+    p_init.add_argument("--write", help="In Zieldatei schreiben oder anhängen")
+    p_init.set_defaults(func=cmd_init_skr)
+
+    # Subcommand: license
+    p_lic = subparsers.add_parser("license", help="Lizenzschlüssel verwalten")
+    p_lic.add_argument(
+        "action", choices=["status", "activate"], help="Aktion (status oder activate)"
+    )
+    p_lic.add_argument("key", nargs="?", help="Lizenzschlüssel bei activate")
+    p_lic.set_defaults(func=cmd_license)
+
+    return parser
+
+
+def main() -> None:
+    """Haupt-Einstiegspunkt für die CLI."""
+    parser = build_parser()
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        sys.exit(args.func(args))
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

euer_datev/config.py

@@ -0,0 +1,262 @@
+"""Konfigurations-Lader und Standard-Templates für euer-datev."""
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from .constants import (
+    DEFAULT_BERATER_NUMMER,
+    DEFAULT_MANDANTEN_NUMMER,
+    EXTF_ACCOUNT_LENGTH_DEFAULT,
+    SKR03_EXPENSE_FALLBACKS,
+    SKR03_FINANCIAL_ACCOUNTS,
+    SKR04_EXPENSE_FALLBACKS,
+    SKR04_FINANCIAL_ACCOUNTS,
+)
+from .models import DatevConfig
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "euer"
+DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.toml"
+
+
+def find_config_path(explicit_path: Path | str | None = None) -> Path:
+    """Ermittelt den Pfad zur config.toml (explizit > Projektverzeichnis > User-Config)."""
+    if explicit_path:
+        return Path(explicit_path)
+
+    # Projekt-lokale Config
+    local_config = Path.cwd() / ".euer" / "config.toml"
+    if local_config.is_file():
+        return local_config
+
+    return DEFAULT_CONFIG_PATH
+
+
+def load_raw_toml(path: Path) -> dict[str, Any]:
+    """Laedt eine TOML-Datei sicher via tomllib."""
+    if not path.is_file():
+        return {}
+    try:
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except Exception as exc:
+        raise ValueError(f"Fehler beim Parsen der Konfigurationsdatei {path}: {exc}") from exc
+
+
+def load_datev_config(
+    config_path: Path | str | None = None,
+    override_year: int | None = None,
+    override_skr: str | None = None,
+    override_berater: str | None = None,
+    override_mandant: str | None = None,
+) -> DatevConfig:
+    """Laedt die DatevConfig aus der Datei und wendet ggf. CLI-Overrides an."""
+    resolved_path = find_config_path(config_path)
+    data = load_raw_toml(resolved_path)
+
+    datev_sec = data.get("datev", {})
+    if not isinstance(datev_sec, dict):
+        datev_sec = {}
+
+    # Grunddaten
+    skr = override_skr or str(datev_sec.get("skr", "03")).strip()
+    if skr not in ("03", "04"):
+        skr = "03"
+
+    berater = (
+        override_berater or str(datev_sec.get("berater_nummer", DEFAULT_BERATER_NUMMER)).strip()
+    )
+    mandant = (
+        override_mandant or str(datev_sec.get("mandanten_nummer", DEFAULT_MANDANTEN_NUMMER)).strip()
+    )
+    mandanten_name = str(
+        datev_sec.get("mandanten_name", data.get("user", {}).get("name", ""))
+    ).strip()
+
+    try:
+        acc_len = int(datev_sec.get("sachkonten_laenge", EXTF_ACCOUNT_LENGTH_DEFAULT))
+    except (ValueError, TypeError):
+        acc_len = EXTF_ACCOUNT_LENGTH_DEFAULT
+
+    # Wirtschaftsjahr Beginn
+    year = override_year or 2026
+    wj_beginn = f"{year}0101"
+
+    # Steuermodus (standard vs small_business)
+    tax_mode = (
+        str(datev_sec.get("tax_mode", data.get("tax", {}).get("mode", "standard"))).strip().lower()
+    )
+    if tax_mode not in ("standard", "small_business"):
+        tax_mode = "standard"
+
+    # Receipts Root
+    receipts_root: Path | None = None
+    receipts_cfg = data.get("receipts", {}).get("root")
+    if receipts_cfg:
+        receipts_root = Path(receipts_cfg).expanduser()
+        if not receipts_root.is_absolute() and resolved_path.is_file():
+            receipts_root = resolved_path.parent / receipts_root
+
+    # Export Dir (unterstützt 'exports.directory' aus euer sowie 'exports.dir')
+    export_dir: Path | None = None
+    export_cfg = data.get("exports", {}).get("directory") or data.get("exports", {}).get("dir")
+    if export_cfg:
+        export_dir = Path(export_cfg).expanduser()
+
+    # Kontenrahmen aus Spec 010 ([[ledger_accounts]]) sowie [datev.ledger_accounts]
+    ledger_mappings: dict[str, str] = {}
+    raw_datev_ledger = datev_sec.get("ledger_accounts", {})
+    if isinstance(raw_datev_ledger, dict):
+        for k, v in raw_datev_ledger.items():
+            if k and v:
+                ledger_mappings[str(k).strip().lower()] = str(v).strip()
+
+    raw_ledger = data.get("ledger_accounts", [])
+    if isinstance(raw_ledger, list):
+        for entry in raw_ledger:
+            if isinstance(entry, dict):
+                acc_num = entry.get("account_number")
+                if not acc_num:
+                    continue
+                acc_str = str(acc_num).strip()
+                for field_name in ("key", "name"):
+                    val = str(entry.get(field_name, "")).strip().lower()
+                    if val and val not in ledger_mappings:
+                        ledger_mappings[val] = acc_str
+
+    # Finanzkonten Mapping:
+    # 1. Prio: [datev.accounts]
+    # 2. Prio: [accounts.mapping] (SPEC-07 Konvention)
+    # 3. Prio: [accounts] (flache Tabelle)
+    fin_mappings: dict[str, str] = {}
+
+    raw_datev_fin = datev_sec.get("accounts", {})
+    if isinstance(raw_datev_fin, dict):
+        for acc_name, acc_num in raw_datev_fin.items():
+            if acc_name and acc_num:
+                fin_mappings[str(acc_name).strip().lower()] = str(acc_num).strip()
+
+    raw_accounts_mapping = data.get("accounts", {}).get("mapping", {})
+    if isinstance(raw_accounts_mapping, dict):
+        for acc_name, acc_num in raw_accounts_mapping.items():
+            key = str(acc_name).strip().lower()
+            acc_val = str(acc_num).strip()
+            if not key or not acc_val:
+                continue
+            # Sachkonten vs Finanzkonten unterscheiden:
+            # SKR03: Finanzkonten 1000-1999; SKR04: 1000-2999
+            is_fin = (skr == "03" and acc_val.startswith("1")) or (
+                skr == "04" and acc_val[:1] in ("1", "2")
+            )
+            if is_fin:
+                if key not in fin_mappings:
+                    fin_mappings[key] = acc_val
+            else:
+                if key not in ledger_mappings:
+                    ledger_mappings[key] = acc_val
+
+    raw_accounts = data.get("accounts", {})
+    if isinstance(raw_accounts, dict):
+        for acc_name, acc_num in raw_accounts.items():
+            if acc_name not in ("private", "mapping") and isinstance(acc_num, (str, int)):
+                key = str(acc_name).strip().lower()
+                acc_val = str(acc_num).strip()
+                if key and acc_val and key not in fin_mappings:
+                    fin_mappings[key] = acc_val
+
+    # Fallback-Finanzkonten ergänzen falls leer
+    defaults_fin = SKR03_FINANCIAL_ACCOUNTS if skr == "03" else SKR04_FINANCIAL_ACCOUNTS
+    for default_name, default_num in defaults_fin.items():
+        if default_name not in fin_mappings:
+            fin_mappings[default_name] = default_num
+
+    return DatevConfig(
+        berater_nummer=berater,
+        mandanten_nummer=mandant,
+        skr=skr,
+        wirtschaftsjahr_beginn=wj_beginn,
+        sachkonten_laenge=acc_len,
+        mandanten_name=mandanten_name,
+        tax_mode=tax_mode,
+        financial_account_mappings=fin_mappings,
+        ledger_account_mappings=ledger_mappings,
+        receipts_root=receipts_root,
+        export_dir=export_dir,
+    )
+
+
+def generate_default_skr_template(skr: str = "03") -> str:
+    """Erzeugt einen empfohlenen [datev]- und [[ledger_accounts]]-Block für config.toml."""
+    fallbacks = SKR03_EXPENSE_FALLBACKS if skr == "03" else SKR04_EXPENSE_FALLBACKS
+    fin_accs = SKR03_FINANCIAL_ACCOUNTS if skr == "03" else SKR04_FINANCIAL_ACCOUNTS
+
+    lines = [
+        "# --- DATEV-Konfiguration (euer-datev) ---",
+        "[datev]",
+        f'berater_nummer = "{DEFAULT_BERATER_NUMMER}"',
+        f'mandanten_nummer = "{DEFAULT_MANDANTEN_NUMMER}"',
+        f'skr = "{skr}"',
+        "sachkonten_laenge = 4",
+        'mandanten_name = "Mein Unternehmen"',
+        "",
+        "[datev.accounts]",
+    ]
+    for name, num in fin_accs.items():
+        lines.append(f'"{name}" = "{num}"')
+
+    lines.extend(
+        [
+            "",
+            f"# --- Buchungskonten (SKR {skr} Vorlage für Spec 010) ---",
+        ]
+    )
+
+    sample_ledger = [
+        (
+            "saas",
+            "Software & SaaS-Lizenzen",
+            "Laufende EDV-Kosten",
+            fallbacks.get("laufende edv-kosten", "4930"),
+        ),
+        ("hosting", "Server & Hosting", "Laufende EDV-Kosten", "4940" if skr == "03" else "6820"),
+        (
+            "gwg",
+            "Geringwertige Wirtschaftsgüter",
+            "Arbeitsmittel",
+            fallbacks.get("arbeitsmittel", "0480"),
+        ),
+        (
+            "telefon",
+            "Telefon & Internet",
+            "Telefon / Internet",
+            fallbacks.get("telefon / internet", "4920"),
+        ),
+        ("reise", "Reisekosten Unternehmer", "Reisekosten", fallbacks.get("reisekosten", "4670")),
+        (
+            "bewirtung",
+            "Geschäftliche Bewirtung 70%",
+            "Bewirtungsaufwendungen",
+            fallbacks.get("bewirtungskosten", "4650"),
+        ),
+        ("werbung", "Marketing & Anzeigen", "Werbekosten", fallbacks.get("werbekosten", "4600")),
+    ]
+
+    for key, name, cat, num in sample_ledger:
+        lines.extend(
+            [
+                "[[ledger_accounts]]",
+                f'key = "{key}"',
+                f'name = "{name}"',
+                f'category = "{cat}"',
+                f'account_number = "{num}"',
+                "",
+            ]
+        )
+
+    return "\n".join(lines)