mt940-py 0.1.5__tar.gz

mt940_py-0.1.5/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mt940-py
+Version: 0.1.5
+Summary: Narzędzie do walidacji i konwersji wyciągów bankowych do formatu MT940 (wariant ZBP).
+Author-email: TheUndefined <undefine@aramin.net>
+Requires-Python: >=3.12
+Requires-Dist: mt-940>=4.30.0

mt940_py-0.1.5/README.md

@@ -0,0 +1,25 @@
+# mt940-py
+
+Biblioteka i narzędzie do walidacji oraz konwersji wyciągów bankowych do formatu MT940 (wariant polski ZBP).
+
+## Główne funkcjonalności
+- **Walidacja**: Sprawdzanie spójności logicznej plików MT940 (sumy kontrolne sald i transakcji).
+- **Konwersja**: Tworzenie plików MT940 z wyciągów CSV (obecnie wspiera mBank).
+- **Eksport**: Konwersja MT940 do czytelnego formatu CSV.
+- **Interfejsy**: Biblioteka Python, CLI oraz nowoczesne GUI (CustomTkinter).
+
+## Instalacja
+```bash
+pip install mt940-py
+```
+
+## Użycie CLI
+```bash
+mt940-val gui        # Uruchomienie interfejsu graficznego
+mt940-val validate   # Walidacja pliku
+mt940-val convert    # Konwersja CSV -> MT940
+mt940-val export     # Eksport MT940 -> CSV
+```
+
+## Rozwój
+Projekt używa `black`, `ruff` i `pytest` do zapewnienia wysokiej jakości kodu.

mt940_py-0.1.5/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "mt940-py"
+version = "0.1.5"
+description = "Narzędzie do walidacji i konwersji wyciągów bankowych do formatu MT940 (wariant ZBP)."
+authors = [
+    { name = "TheUndefined", email = "undefine@aramin.net" }
+]
+dependencies = [
+    "mt-940>=4.30.0",
+]
+requires-python = ">=3.12"
+
+[project.scripts]
+mt940-val = "mt940_py.main:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 120
+target-version = ['py312']
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true

mt940_py-0.1.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mt940_py-0.1.5/src/mt940_py/converter.py

@@ -0,0 +1,162 @@
+import csv
+import datetime
+import io
+import re
+from typing import List
+
+class MT940Converter:
+    """Konwerter plików CSV (mBank) do formatu MT940 (ZBP) zgodnego z mBank/Insert."""
+
+    def __init__(self, encoding: str = "cp1250") -> None:
+        self.encoding = encoding
+
+    def _clean_amount_str(self, val: str) -> str:
+        if not val:
+            return "0.0"
+        cleaned = val.replace(" PLN", "").replace(" ", "").replace(",", ".").replace("\xa0", "")
+        cleaned = re.sub(r"[^\d.-]", "", cleaned)
+        return cleaned
+
+    def _format_amount(self, amount: float) -> str:
+        return f"{abs(amount):.2f}".replace(".", ",")
+
+    def _format_date(self, date_str: str) -> str:
+        try:
+            dt = datetime.datetime.strptime(date_str, "%Y-%m-%d")
+            return dt.strftime("%y%m%d")
+        except (ValueError, TypeError):
+            return ""
+
+    def _wrap_text(self, text: str, length: int) -> List[str]:
+        if not text:
+            return []
+        return [text[i : i + length] for i in range(0, len(text), length)]
+
+    def convert(self, csv_content: str) -> str:
+        lines = [line.strip() for line in csv_content.splitlines()]
+        header_index = -1
+        for i, line in enumerate(lines):
+            if "#Data księgowania;" in line:
+                header_index = i
+                break
+
+        if header_index == -1:
+            raise ValueError("Nie znaleziono nagłówka transakcji w pliku CSV.")
+
+        account_number = ""
+        initial_balance = 0.0
+        currency = "PLN"
+        statement_date = ""
+
+        for i, line in enumerate(lines[:header_index]):
+            if "#Numer rachunku" in line:
+                content = line
+                if i + 1 < header_index and (len(line.split(";")) <= 1 or not line.split(";")[1].strip()):
+                    content = lines[i + 1]
+                match = re.search(r"(\d[\s\d]{20,})", content)
+                if match:
+                    account_number = re.sub(r"[^\d]", "", match.group(1))
+
+            if "#Saldo początkowe" in line:
+                content = line
+                if i + 1 < header_index and (len(line.split(";")) <= 1 or not line.split(";")[1].strip()):
+                    content = lines[i + 1]
+                try:
+                    parts = content.split(";")
+                    val_str = self._clean_amount_str(parts[1] if len(parts) > 1 else parts[0])
+                    initial_balance = float(val_str)
+                except (IndexError, ValueError):
+                    pass
+
+        f = io.StringIO("\n".join(lines[header_index:]))
+        reader = csv.DictReader(f, delimiter=";")
+        
+        # Przygotowanie transakcji do późniejszego użycia (potrzebujemy daty pierwszej transakcji)
+        rows = []
+        for row in reader:
+            raw_date = row.get("#Data księgowania")
+            if raw_date and re.match(r"\d{4}-\d{2}-\d{2}", raw_date):
+                rows.append(row)
+        
+        if rows and not statement_date:
+            statement_date = self._format_date(rows[0]["#Data księgowania"])
+        else:
+            statement_date = datetime.datetime.now().strftime("%y%m%d")
+
+        output = []
+        # :20:
+        output.append(":20:MT940")
+
+        # :25:
+        if account_number:
+            output.append(f":25:/PL{account_number}")
+        else:
+            output.append(":25:/UNKNOWN_ACCOUNT")
+
+        # :28C: Numer wyciągu (mBank używa daty YYMMDD)
+        output.append(f":28C:{statement_date}")
+
+        # :60F: Saldo początkowe
+        sign_60 = "C" if initial_balance >= 0 else "D"
+        output.append(f":60F:{sign_60}{statement_date}{currency}{self._format_amount(initial_balance)}")
+
+        current_balance = initial_balance
+        
+        for idx, row in enumerate(rows):
+            date_val = self._format_date(row["#Data księgowania"])
+            amount = float(self._clean_amount_str(row.get("#Kwota", "0")))
+            current_balance += amount
+
+            # :61: Linia transakcji
+            # Dodajemy numer referencyjny na końcu (np. SD95 + numer kolejny)
+            sign_61 = "C" if amount >= 0 else "D"
+            ref_num = f"{idx+1:011d}"
+            output.append(f":61:{date_val}{date_val[2:]}{sign_61}{self._format_amount(amount)}SD95{ref_num}")
+
+            # :86: Struktura mBanku (podwójny tag :86: i brak :86: w kolejnych liniach pola)
+            output.append(":86:SD95")
+            
+            operation_type = row.get("#Opis operacji", "")
+            title = row.get("#Tytuł", "")
+            
+            # Budujemy linię 2 pola 86
+            details_line2 = f"SD95~00BD95{operation_type}"
+            # Kolejne linie tytułu i danych
+            details_remaining = []
+            
+            title_parts = self._wrap_text(title, 27)
+            for i, part in enumerate(title_parts[:8]):
+                details_remaining.append(f"~{20+i}{part}")
+                
+            contractor = row.get("#Nadawca/Odbiorca", "")
+            contractor_parts = self._wrap_text(contractor, 35)
+            if len(contractor_parts) > 0:
+                details_remaining.append(f"~32{contractor_parts[0]}")
+            if len(contractor_parts) > 1:
+                details_remaining.append(f"~33{contractor_parts[1]}")
+                
+            acc = row.get("#Numer konta", "").replace("'", "").strip()
+            if acc:
+                acc_clean = re.sub(r"[^\d]", "", acc)
+                if acc_clean:
+                    details_remaining.append(f"~31{acc_clean}")
+                    details_remaining.append(f"~38PL{acc_clean}")
+
+            # Składamy wszystko w całość zgodnie z formatem mBanku
+            # Pierwsza linia po :86: (druga w sumie)
+            raw_full_86 = "".join(details_remaining)
+            wrapped_86 = self._wrap_text(raw_full_86, 65)
+            
+            output.append(f":86:{details_line2}")
+            for line in wrapped_86:
+                output.append(line)
+
+        # :62F:
+        sign_62 = "C" if current_balance >= 0 else "D"
+        # Data salda końcowego z ostatniej transakcji lub dzisiejsza
+        last_date = self._format_date(rows[-1]["#Data księgowania"]) if rows else statement_date
+        output.append(f":62F:{sign_62}{last_date}{currency}{self._format_amount(current_balance)}")
+
+        # Dodajemy znak końca pliku (opcjonalnie, ale mBank często go nie ma, SWIFT wymaga tylko pól)
+        # Łączymy używając CRLF
+        return "\r\n".join(output) + "\r\n"

mt940_py-0.1.5/src/mt940_py/exporter.py

@@ -0,0 +1,77 @@
+import csv
+import io
+import re
+import mt940
+from mt940_py.validator import MT940Validator
+
+
+class MT940ToCSVExporter:
+    """Eksporter plików MT940 do formatu CSV."""
+
+    def __init__(self) -> None:
+        self.validator = MT940Validator()
+
+    def _clean_text(self, text: str) -> str:
+        """Usuwa znaki nowej linii i nadmiarowe spacje."""
+        if not text:
+            return ""
+        # Zamieniamy nową linię na spację
+        cleaned = text.replace("\n", " ").replace("\r", " ")
+        # Usuwamy wielokrotne spacje
+        cleaned = re.sub(r"\s+", " ", cleaned)
+        return cleaned.strip()
+
+    def export(self, mt940_path: str) -> str:
+        statements = mt940.parse(mt940_path)
+
+        output = io.StringIO()
+        fieldnames = [
+            "Data księgowania",
+            "Kwota",
+            "Waluta",
+            "Typ",
+            "Kontrahent",
+            "Rachunek kontrahenta",
+            "Tytuł",
+            "Szczegóły RAW",
+        ]
+
+        writer = csv.DictWriter(output, fieldnames=fieldnames, delimiter=";")
+        writer.writeheader()
+
+        if hasattr(statements, "data"):
+            statements_list = [statements]
+        else:
+            statements_list = statements
+
+        for statement in statements_list:
+            for transaction in statement:
+                data = transaction.data
+                raw_86 = data.get("transaction_details", "")
+                parsed_86 = self.validator.parse_field_86(raw_86)
+
+                title_parts = []
+                for i in range(20, 28):
+                    val = parsed_86.get(str(i))
+                    if val:
+                        title_parts.append(val)
+
+                contractor = f"{parsed_86.get('32', '')} {parsed_86.get('33', '')}".strip()
+                acc = parsed_86.get("31", parsed_86.get("38", ""))
+
+                amount = self.validator.get_amount_value(data.get("amount"))
+
+                writer.writerow(
+                    {
+                        "Data księgowania": data.get("date"),
+                        "Kwota": f"{amount:.2f}",
+                        "Waluta": data.get("currency"),
+                        "Typ": data.get("status"),
+                        "Kontrahent": self._clean_text(contractor),
+                        "Rachunek kontrahenta": self._clean_text(acc),
+                        "Tytuł": self._clean_text(" ".join(title_parts)),
+                        "Szczegóły RAW": self._clean_text(raw_86),
+                    }
+                )
+
+        return output.getvalue()

mt940_py-0.1.5/src/mt940_py/gui.py

@@ -0,0 +1,115 @@
+import os
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import customtkinter as ctk
+from mt940_py.converter import MT940Converter
+from mt940_py.validator import MT940Validator
+
+# Ustawienia wyglądu
+ctk.set_appearance_mode("System")
+ctk.set_default_color_theme("blue")
+
+class MT940App(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+
+        self.title("MT940-py: Konwerter i Walidator")
+        self.geometry("600x450")
+
+        self.converter = MT940Converter()
+        self.validator = MT940Validator()
+
+        # Układ siatki
+        self.grid_columnconfigure(0, weight=1)
+        self.grid_rowconfigure(3, weight=1)
+
+        # Nagłówek
+        self.label = ctk.CTkLabel(self, text="Konwerter mBank CSV -> MT940", font=ctk.CTkFont(size=20, weight="bold"))
+        self.label.grid(row=0, column=0, padx=20, pady=(20, 10))
+
+        # Przyciski akcji
+        self.button_frame = ctk.CTkFrame(self)
+        self.button_frame.grid(row=1, column=0, padx=20, pady=10, sticky="nsew")
+        self.button_frame.grid_columnconfigure((0, 1), weight=1)
+
+        self.select_button = ctk.CTkButton(self.button_frame, text="Wybierz plik CSV (mBank)", command=self.select_file)
+        self.select_button.grid(row=0, column=0, padx=10, pady=10)
+
+        self.val_button = ctk.CTkButton(self.button_frame, text="Waliduj plik MT940", command=self.validate_mt940, fg_color="gray")
+        self.val_button.grid(row=0, column=1, padx=10, pady=10)
+
+        # Status pliku
+        self.status_label = ctk.CTkLabel(self, text="Nie wybrano pliku", font=ctk.CTkFont(slant="italic"))
+        self.status_label.grid(row=2, column=0, padx=20, pady=5)
+
+        # Logi / Wyniki
+        self.textbox = ctk.CTkTextbox(self, width=560)
+        self.textbox.grid(row=3, column=0, padx=20, pady=10, sticky="nsew")
+        self.textbox.insert("0.0", "System gotowy.\n\n")
+
+    def log(self, message: str):
+        self.textbox.insert("end", f"{message}\n")
+        self.textbox.see("end")
+
+    def select_file(self):
+        file_path = filedialog.askopenfilename(
+            title="Wybierz plik mBank CSV",
+            filetypes=[("Pliki CSV", "*.csv"), ("Wszystkie pliki", "*.*")]
+        )
+        if file_path:
+            self.status_label.configure(text=f"Wybrano: {os.path.basename(file_path)}")
+            self.process_conversion(file_path)
+
+    def process_conversion(self, input_path: str):
+        output_path = filedialog.asksaveasfilename(
+            title="Zapisz jako MT940",
+            defaultextension=".txt",
+            initialfile=os.path.basename(input_path).replace(".csv", ".txt"),
+            filetypes=[("Pliki tekstowe", "*.txt"), ("Pliki MT940", "*.sta"), ("Wszystkie pliki", "*.*")]
+        )
+
+        if not output_path:
+            return
+
+        try:
+            self.log(f"Rozpoczynam konwersję: {os.path.basename(input_path)}...")
+            with open(input_path, "r", encoding="cp1250", errors="replace") as f:
+                content = f.read()
+            
+            mt940_content = self.converter.convert(content)
+            # Zapisujemy jako UTF-8 z BOM (utf-8-sig)
+            with open(output_path, "w", encoding="utf-8-sig") as f:
+                f.write(mt940_content)
+            
+            self.log(f"SUCCESS: Zapisano do {output_path}")
+            val_results = self.validator.validate_file(output_path)
+            if val_results["is_valid"]:
+                self.log(f"Walidacja OK: {val_results['statements_count']} wyciągów.")
+                messagebox.showinfo("Sukces", "Konwersja zakończona pomyślnie!")
+            else:
+                self.log("BŁĄD WALIDACJI wygenerowanego pliku!")
+                messagebox.showwarning("Uwaga", "Plik wygenerowany, ale zawiera błędy logiczne.")
+        except Exception as e:
+            self.log(f"ERROR: {str(e)}")
+            messagebox.showerror("Błąd", str(e))
+
+    def validate_mt940(self):
+        file_path = filedialog.askopenfilename(
+            title="Wybierz plik MT940",
+            filetypes=[("Pliki tekstowe", "*.txt"), ("Pliki MT940", "*.sta"), ("Wszystkie pliki", "*.*")]
+        )
+        if file_path:
+            val_results = self.validator.validate_file(file_path)
+            if val_results["is_valid"]:
+                self.log(f"SUCCESS: Plik {os.path.basename(file_path)} poprawny.")
+                messagebox.showinfo("OK", "Plik jest poprawny.")
+            else:
+                self.log(f"FAILURE: Plik {os.path.basename(file_path)} błędny.")
+                messagebox.showerror("Błąd", "Plik zawiera błędy.")
+
+def main():
+    app = MT940App()
+    app.mainloop()
+
+if __name__ == "__main__":
+    main()

mt940_py-0.1.5/src/mt940_py/main.py

@@ -0,0 +1,75 @@
+import sys
+import io
+
+# Fix for libraries that expect sys.stdout/stderr to be present (like mt-940)
+# especially when compiled with --noconsole
+if sys.stdout is None:
+    sys.stdout = io.StringIO()
+if sys.stderr is None:
+    sys.stderr = io.StringIO()
+
+import argparse
+import os
+from mt940_py.validator import MT940Validator
+from mt940_py.converter import MT940Converter
+from mt940_py.exporter import MT940ToCSVExporter
+
+def main():
+    parser = argparse.ArgumentParser(description="Narzędzie MT940: CLI & GUI.")
+    subparsers = parser.add_subparsers(dest="command", help="Komenda do wykonania")
+
+    # CLI commands
+    subparsers.add_parser("validate", help="Waliduje plik MT940").add_argument("file")
+    
+    conv_parser = subparsers.add_parser("convert", help="Konwertuje CSV to MT940")
+    conv_parser.add_argument("input")
+    conv_parser.add_argument("output")
+
+    exp_parser = subparsers.add_parser("export", help="Eksportuje MT940 to CSV")
+    exp_parser.add_argument("input")
+    exp_parser.add_argument("output")
+
+    # GUI command
+    subparsers.add_parser("gui", help="Uruchamia interfejs graficzny")
+
+    args = parser.parse_args()
+
+    if args.command == "gui":
+        from mt940_py.gui import main as run_gui
+        run_gui()
+    elif args.command == "validate":
+        validator = MT940Validator()
+        results = validator.validate_file(args.file)
+        if results["is_valid"]:
+            print(f"SUCCESS: {results['statements_count']} wyciągów, {results['transactions_count']} transakcji.")
+        else:
+            print("FAILURE: Błędy:")
+            for err in results["errors"]: print(f" - {err}")
+            sys.exit(1)
+    elif args.command == "convert":
+        try:
+            with open(args.input, 'r', encoding='cp1250', errors='replace') as f:
+                mt940_res = MT940Converter().convert(f.read())
+            # Zapisujemy jako UTF-8 z BOM (utf-8-sig)
+            with open(args.output, 'w', encoding='utf-8-sig') as f:
+                f.write(mt940_res)
+            print(f"SUCCESS: {args.output}")
+        except Exception as e:
+            print(f"ERROR: {e}")
+            sys.exit(1)
+    elif args.command == "export":
+        try:
+            csv_res = MT940ToCSVExporter().export(args.input)
+            with open(args.output, 'w', encoding='utf-8') as f:
+                f.write(csv_res)
+            print(f"SUCCESS: {args.output}")
+        except Exception as e:
+            print(f"ERROR: {e}")
+            sys.exit(1)
+    else:
+        # Default to GUI if no command
+        from mt940_py.gui import main as run_gui
+        run_gui()
+
+if __name__ == "__main__":
+    main()

mt940_py-0.1.5/src/mt940_py/validator.py

@@ -0,0 +1,84 @@
+import re
+from typing import Dict, Any, List
+import mt940  # type: ignore
+
+class MT940Validator:
+    """Walidator plików MT940 z uwzględnieniem polskich rozszerzeń ZBP."""
+
+    def __init__(self) -> None:
+        pass
+
+    def parse_field_86(self, raw_details: str) -> Dict[str, str]:
+        if not raw_details:
+            return {}
+        parts = re.split(r"~(\d{2})", raw_details)
+        parsed: Dict[str, str] = {}
+        if len(parts) > 1:
+            for i in range(1, len(parts), 2):
+                tag = parts[i]
+                value = parts[i + 1].strip() if i + 1 < len(parts) else ""
+                if tag in parsed:
+                    parsed[tag] += " " + value
+                else:
+                    parsed[tag] = value
+        return parsed
+
+    def get_amount_value(self, obj: Any) -> float:
+        if obj is None:
+            return 0.0
+        if hasattr(obj, "amount") and hasattr(obj.amount, "amount"):
+            return float(obj.amount.amount)
+        if hasattr(obj, "amount"):
+            return float(obj.amount)
+        try:
+            return float(obj)
+        except Exception:
+            return 0.0
+
+    def validate_file(self, file_path: str) -> Dict[str, Any]:
+        results: Dict[str, Any] = {
+            "is_valid": True,
+            "errors": [],
+            "statements_count": 0,
+            "transactions_count": 0,
+        }
+
+        try:
+            data = mt940.parse(file_path)
+
+            if hasattr(data, "data"):
+                statements = [data]
+            else:
+                statements = data
+
+            results["statements_count"] = len(statements)
+
+            for statement in statements:
+                opening = statement.data.get("final_opening_balance")
+                closing = statement.data.get("final_closing_balance")
+
+                initial_val = self.get_amount_value(opening)
+                expected_final = self.get_amount_value(closing)
+
+                actual_sum = initial_val
+
+                for transaction in statement:
+                    results["transactions_count"] += 1
+                    amount = transaction.data.get("amount")
+                    actual_sum += self.get_amount_value(amount)
+
+                    raw_86 = transaction.data.get("transaction_details", "")
+                    self.parse_field_86(raw_86)
+
+                if abs(actual_sum - expected_final) > 0.01:
+                    results["is_valid"] = False
+                    results["errors"].append(
+                        f"Błąd sumy kontrolnej: Saldo pocz. ({initial_val:.2f}) + transakcje = {actual_sum:.2f}, "
+                        f"a saldo końcowe w pliku to {expected_final:.2f}"
+                    )
+
+        except Exception as e:
+            results["is_valid"] = False
+            results["errors"].append(f"Błąd krytyczny parsowania: {str(e)}")
+
+        return results

mt940_py-0.1.5/src/mt940_py.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mt940-py
+Version: 0.1.5
+Summary: Narzędzie do walidacji i konwersji wyciągów bankowych do formatu MT940 (wariant ZBP).
+Author-email: TheUndefined <undefine@aramin.net>
+Requires-Python: >=3.12
+Requires-Dist: mt-940>=4.30.0

mt940_py-0.1.5/src/mt940_py.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/mt940_py/converter.py
+src/mt940_py/exporter.py
+src/mt940_py/gui.py
+src/mt940_py/main.py
+src/mt940_py/validator.py
+src/mt940_py.egg-info/PKG-INFO
+src/mt940_py.egg-info/SOURCES.txt
+src/mt940_py.egg-info/dependency_links.txt
+src/mt940_py.egg-info/entry_points.txt
+src/mt940_py.egg-info/requires.txt
+src/mt940_py.egg-info/top_level.txt
+tests/test_converter.py
+tests/test_validator.py

mt940_py-0.1.5/src/mt940_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mt940_py-0.1.5/src/mt940_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mt940-val = mt940_py.main:main

mt940_py-0.1.5/src/mt940_py.egg-info/requires.txt

@@ -0,0 +1 @@
+mt-940>=4.30.0

mt940_py-0.1.5/src/mt940_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+mt940_py

mt940_py-0.1.5/tests/test_converter.py

@@ -0,0 +1,35 @@
+import pytest
+from mt940_py.converter import MT940Converter
+
+def test_clean_amount_str():
+    conv = MT940Converter()
+    assert conv._clean_amount_str("1 234,56 PLN") == "1234.56"
+    assert conv._clean_amount_str("-75,82") == "-75.82"
+
+def test_format_amount():
+    conv = MT940Converter()
+    assert conv._format_amount(1234.56) == "1234,56"
+
+def test_format_date():
+    conv = MT940Converter()
+    assert conv._format_date("2026-01-10") == "260110"
+
+def test_basic_conversion_structure():
+    # Bardziej realistyczny format mBanku
+    csv_content = (
+        "#Numer rachunku;PL12345678901234567890123456;\n"
+        "#Saldo początkowe;100,00 PLN;\n"
+        "#Data księgowania;#Data operacji;#Opis operacji;#Tytuł;#Nadawca/Odbiorca;#Numer konta;#Kwota;#Saldo po operacji;\n"
+        "2026-01-10;2026-01-10;OPIS;TYTUL;NADAWCA;112233;-10,00;90,00;\n"
+    )
+    conv = MT940Converter()
+    result = conv.convert(csv_content)
+    
+    assert ":20:MT940" in result
+    assert "/PL12345678901234567890123456" in result
+    assert ":60F:C260110PLN100,00" in result
+    assert "D10,00" in result
+    assert ":62F:C260110PLN90,00" in result
+    assert "\r\n" in result
+    # Sprawdzenie podwójnego 86
+    assert ":86:SD95\r\n:86:SD95~00BD95OPIS" in result

mt940_py-0.1.5/tests/test_validator.py

@@ -0,0 +1,47 @@
+import pytest
+import os
+from mt940_py.validator import MT940Validator
+from mt940_py.converter import MT940Converter
+
+def test_validator_success():
+    csv_content = (
+        "#Numer rachunku;1234567890\n"
+        "#Saldo początkowe;100,00\n"
+        "#Data księgowania;Tytuł;Kwota\n"
+        "2026-01-10;TEST;50,00\n"
+    )
+    conv = MT940Converter()
+    mt940_data = conv.convert(csv_content)
+    
+    temp_path = "tests/temp_test.txt"
+    with open(temp_path, "w", encoding="utf-8") as f:
+        f.write(mt940_data)
+    
+    validator = MT940Validator()
+    results = validator.validate_file(temp_path)
+    
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+    
+    assert results["is_valid"] is True
+
+def test_validator_error():
+    bad_mt940 = (
+        ":20:MT940\r\n"
+        ":25:/PL123\r\n"
+        ":60F:C260101PLN100,00\r\n"
+        ":61:2601010101C50,00SD95\r\n"
+        ":86:TEST\r\n"
+        ":62F:C260101PLN200,00\r\n"
+    )
+    temp_path = "tests/temp_bad.txt"
+    with open(temp_path, "w", encoding="utf-8") as f:
+        f.write(bad_mt940)
+        
+    validator = MT940Validator()
+    results = validator.validate_file(temp_path)
+    
+    if os.path.exists(temp_path):
+        os.remove(temp_path)
+    
+    assert results["is_valid"] is False