fix: self-contained Colab notebook - inline C source, no git dependency

test_wine_colab.ipynb

@@ -5,20 +5,20 @@
    "id": "d603dd1d",
    "metadata": {},
    "source": [
-    "# OneOCR — Wine Bridge Test na Linux\n",
+    "# OneOCR — Wine Bridge Test na Linux (Colab)\n",
     "\n",
-    "Test czy `oneocr.dll` działa na Linuxie przez Wine → **100% accuracy**.\n",
+    "Test czy `oneocr.dll` działa na Linuxie przez Wine.\n",
     "\n",
     "**Kroki:**\n",
-    "1. Instalacja Wine + MinGW na Ubuntu (Colab)\n",
-    "2. Clone repo + **ręczny upload DLL** do `ocr_data/`\n",
-    "3. Kompilacja C loadera\n",
-    "4. Uruchomienie DLL przez Wine → OCR na obrazach testowych\n",
-    "\n",
-    "**Potrzebne pliki** (wrzuć po komórce 4):\n",
-    "- `oneocr.dll` (40 MB)\n",
-    "- `oneocr.onemodel` (56 MB)\n",
-    "- `onnxruntime.dll` (13 MB)"
+    "1. Instalacja Wine + MinGW\n",
+    "2. Clone repo + upload DLL\n",
+    "3. Diagnostyka Wine (debug loader)\n",
+    "4. Test OCR przez Wine\n",
+    "\n",
+    "**Potrzebne pliki** (wrzuć w komórce 4):\n",
+    "- `oneocr.dll` (~40 MB)\n",
+    "- `oneocr.onemodel` (~56 MB)\n",
+    "- `onnxruntime.dll` (~13 MB)"
    ]
   },
   {
@@ -28,23 +28,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 1. Install Wine + MinGW (use WineHQ repo for latest stable)\n",
-    "import subprocess, os\n",
-    "\n",
-    "# Add WineHQ repo for latest stable Wine (Ubuntu's stock is old)\n",
-    "cmds = [\n",
-    "    'dpkg --add-architecture i386',\n",
-    "    'mkdir -pm755 /etc/apt/keyrings',\n",
-    "    'wget -qO /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key 2>/dev/null || true',\n",
-    "    'apt-get update -qq',\n",
-    "    'apt-get install -y -qq wine64 mingw-w64 > /dev/null 2>&1',\n",
-    "]\n",
-    "for cmd in cmds:\n",
-    "    subprocess.run(cmd, shell=True, capture_output=True)\n",
-    "\n",
-    "# Show Wine version\n",
+    "# 1. Install Wine + MinGW\n",
+    "!dpkg --add-architecture i386\n",
+    "!apt-get update -qq 2>/dev/null\n",
+    "!apt-get install -y -qq wine64 mingw-w64 2>&1 | tail -1\n",
     "!wine64 --version\n",
-    "!x86_64-w64-mingw32-gcc --version | head -1"
+    "!x86_64-w64-mingw32-gcc --version 2>&1 | head -1\n",
+    "print(\"OK\")"
    ]
   },
   {
@@ -54,15 +44,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 2. Initialize Wine prefix (64-bit, suppress noise)\n",
+    "# 2. Initialize Wine prefix\n",
     "import os\n",
     "os.environ['WINEDEBUG'] = '-all'\n",
     "os.environ['WINEPREFIX'] = '/root/.wine'\n",
     "os.environ['WINEARCH'] = 'win64'\n",
     "!wineboot --init 2>/dev/null\n",
-    "!echo \"Wine prefix initialized\"\n",
-    "# Verify Wine can run basic exe\n",
-    "!echo 'int main(){return 0;}' > /tmp/test.c && x86_64-w64-mingw32-gcc -o /tmp/test.exe /tmp/test.c && wine64 /tmp/test.exe && echo \"Wine runs MinGW executables OK\""
+    "print(\"Wine prefix OK\")"
    ]
   },
   {
@@ -72,14 +60,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 3. Clone repo from HuggingFace\n",
-    "!pip install -q huggingface_hub 2>/dev/null\n",
-    "!git lfs install\n",
-    "!git clone https://huggingface.co/MattyMroz/oneocr /content/oneocr 2>/dev/null || (cd /content/oneocr && git pull)\n",
+    "# 3. Clone repo\n",
+    "!rm -rf /content/oneocr\n",
+    "!git lfs install 2>/dev/null\n",
+    "!git clone https://huggingface.co/MattyMroz/oneocr /content/oneocr\n",
     "!mkdir -p /content/oneocr/ocr_data\n",
-    "!ls -la /content/oneocr/tools/\n",
-    "print(\"\\n--- ocr_data/ contents ---\")\n",
-    "!ls -la /content/oneocr/ocr_data/ 2>/dev/null || echo \"ocr_data/ is empty — upload DLLs in next cell\""
+    "!ls /content/oneocr/tools/*.c\n",
+    "print(\"Repo OK\")"
    ]
   },
   {
@@ -89,70 +76,42 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 4. ⬆️ UPLOAD DLL FILES HERE ⬆️\n",
-    "# \n",
-    "# Opcja A: Upload przez Colab (kliknij \"Files\" po lewej → Upload)\n",
-    "#   Wrzuć: oneocr.dll, oneocr.onemodel, onnxruntime.dll\n",
-    "#   Potem uruchom tę komórkę żeby przenieść do ocr_data/\n",
+    "# 4. UPLOAD DLL FILES\n",
+    "#\n",
+    "# Kliknij \"Files\" po lewej w Colab -> Upload\n",
+    "# Wrzuc: oneocr.dll, oneocr.onemodel, onnxruntime.dll\n",
+    "# Potem uruchom te komorke\n",
     "#\n",
-    "# Opcja B: Jeśli masz na Google Drive:\n",
+    "# Albo z Google Drive:\n",
     "#   from google.colab import drive\n",
     "#   drive.mount('/content/drive')\n",
-    "#   !cp /content/drive/MyDrive/ścieżka/{oneocr.dll,oneocr.onemodel,onnxruntime.dll} /content/oneocr/ocr_data/\n",
+    "#   !cp /content/drive/MyDrive/path/{oneocr.dll,oneocr.onemodel,onnxruntime.dll} /content/oneocr/ocr_data/\n",
     "\n",
-    "import shutil, os\n",
+    "import shutil\n",
     "from pathlib import Path\n",
     "\n",
     "ocr_data = Path('/content/oneocr/ocr_data')\n",
-    "needed = {\n",
-    "    'oneocr.dll': 40_000_000,       # ~40 MB\n",
-    "    'oneocr.onemodel': 50_000_000,  # ~56 MB  \n",
-    "    'onnxruntime.dll': 10_000_000,  # ~13 MB\n",
-    "}\n",
+    "needed = {'oneocr.dll': 40e6, 'oneocr.onemodel': 50e6, 'onnxruntime.dll': 10e6}\n",
     "\n",
-    "# Search multiple possible locations\n",
-    "search_dirs = [Path('/content'), Path('/root'), Path('/tmp')]\n",
-    "\n",
-    "for f, min_size in needed.items():\n",
+    "for f, minsize in needed.items():\n",
     "    dst = ocr_data / f\n",
-    "    if dst.exists() and dst.stat().st_size > min_size:\n",
-    "        print(f'  ✅ Już jest: {f} ({dst.stat().st_size / 1e6:.1f} MB)')\n",
-    "        continue\n",
-    "    \n",
-    "    # Find the file\n",
-    "    found = False\n",
-    "    for d in search_dirs:\n",
-    "        src = d / f\n",
-    "        if src.exists() and src.stat().st_size > min_size:\n",
-    "            shutil.copy2(str(src), str(dst))\n",
-    "            print(f'  ✅ Skopiowano: {f} ({dst.stat().st_size / 1e6:.1f} MB)')\n",
-    "            found = True\n",
-    "            break\n",
-    "    \n",
-    "    if not found:\n",
-    "        if dst.exists():\n",
-    "            size = dst.stat().st_size\n",
-    "            if size < 1000:\n",
-    "                # Likely git LFS pointer\n",
-    "                print(f'  ❌ {f} — to git LFS pointer ({size} B)! Wrzuć prawdziwy plik.')\n",
-    "                with open(dst) as fh:\n",
-    "                    print(f'     Zawartość: {fh.read(100)[:80]}...')\n",
-    "            else:\n",
-    "                print(f'  ⚠️ {f} istnieje ale mały ({size / 1e6:.1f} MB) — sprawdź!')\n",
+    "    # szukaj w /content/ (domyslny upload Colab)\n",
+    "    src = Path(f'/content/{f}')\n",
+    "    if src.exists() and not dst.exists():\n",
+    "        shutil.move(str(src), str(dst))\n",
+    "    if dst.exists():\n",
+    "        sz = dst.stat().st_size\n",
+    "        if sz > minsize:\n",
+    "            print(f'  OK: {f} ({sz/1e6:.1f} MB)')\n",
+    "        elif sz < 1000:\n",
+    "            print(f'  BLAD: {f} to git LFS pointer! Wrzuc prawdziwy plik.')\n",
     "        else:\n",
-    "            print(f'  ❌ BRAK: {f} — wrzuć plik!')\n",
+    "            print(f'  UWAGA: {f} maly ({sz/1e6:.1f} MB)')\n",
+    "    else:\n",
+    "        print(f'  BRAK: {f} - wrzuc plik!')\n",
     "\n",
-    "# Final check\n",
-    "print()\n",
-    "all_ok = True\n",
-    "for f, min_size in needed.items():\n",
-    "    dst = ocr_data / f\n",
-    "    if not dst.exists() or dst.stat().st_size < min_size:\n",
-    "        all_ok = False\n",
-    "if all_ok:\n",
-    "    print('🎉 Wszystkie pliki na miejscu!')\n",
-    "else:\n",
-    "    print('⚠️ Brakuje plików — wrzuć je i uruchom tę komórkę ponownie.')"
+    "ok = all((ocr_data / f).exists() and (ocr_data / f).stat().st_size > s for f, s in needed.items())\n",
+    "print(f'\\n{\"Wszystkie pliki OK!\" if ok else \"BRAK PLIKOW - wrzuc i uruchom ponownie\"}')"
    ]
   },
   {
@@ -173,11 +132,174 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 6. Compile BOTH loaders: debug + normal\n",
-    "!x86_64-w64-mingw32-gcc -O2 -o /content/oneocr/tools/oneocr_debug.exe /content/oneocr/tools/oneocr_debug.c\n",
-    "!x86_64-w64-mingw32-gcc -O2 -o /content/oneocr/tools/oneocr_loader.exe /content/oneocr/tools/oneocr_loader.c\n",
-    "!ls -la /content/oneocr/tools/*.exe\n",
-    "print('✅ Both loaders compiled')"
+    "# 6. Compile C loaders (source written INLINE - no git dependency)\n",
+    "import subprocess, os\n",
+    "\n",
+    "# ========== DEBUG LOADER SOURCE ==========\n",
+    "DEBUG_C = r\"\"\"\n",
+    "#include <stdio.h>\n",
+    "#include <stdlib.h>\n",
+    "#include <string.h>\n",
+    "#include <windows.h>\n",
+    "typedef void* BCRYPT_ALG_HANDLE;\n",
+    "typedef void* BCRYPT_KEY_HANDLE;\n",
+    "typedef long NTSTATUS;\n",
+    "typedef NTSTATUS (*fn_Open)(BCRYPT_ALG_HANDLE*, const wchar_t*, const wchar_t*, unsigned long);\n",
+    "typedef NTSTATUS (*fn_SetP)(BCRYPT_ALG_HANDLE, const wchar_t*, unsigned char*, unsigned long, unsigned long);\n",
+    "typedef NTSTATUS (*fn_GenK)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE*, unsigned char*, unsigned long, unsigned char*, unsigned long, unsigned long);\n",
+    "typedef NTSTATUS (*fn_Dec)(BCRYPT_KEY_HANDLE, unsigned char*, unsigned long, void*, unsigned char*, unsigned long, unsigned char*, unsigned long, unsigned long*, unsigned long);\n",
+    "typedef NTSTATUS (*fn_Close)(BCRYPT_ALG_HANDLE, unsigned long);\n",
+    "typedef NTSTATUS (*fn_DestK)(BCRYPT_KEY_HANDLE);\n",
+    "typedef long long (*fn_CrInit)(long long*);\n",
+    "typedef long long (*fn_SetDL)(long long, char);\n",
+    "typedef long long (*fn_CrPipe)(const char*, const char*, long long, long long*);\n",
+    "typedef void (*fn_RelInit)(long long);\n",
+    "typedef void (*fn_RelPipe)(long long);\n",
+    "\n",
+    "int main(int argc, char** argv) {\n",
+    "    if (argc < 2) { fprintf(stderr, \"Usage: %s <dll_dir> [key_hex]\\n\", argv[0]); return 1; }\n",
+    "    const char* dd = argv[1];\n",
+    "    const char* kh = argc>2 ? argv[2] : \"6b6a29544774724b3e665d625b50696f772e67552b6e43407322222222222234\";\n",
+    "    char p[MAX_PATH];\n",
+    "\n",
+    "    printf(\"=== TEST 1: File Access ===\\n\");\n",
+    "    const char* files[] = {\"oneocr.onemodel\", \"oneocr.dll\", \"onnxruntime.dll\", NULL};\n",
+    "    for (int i=0; files[i]; i++) {\n",
+    "        snprintf(p, sizeof(p), \"%s\\\\%s\", dd, files[i]);\n",
+    "        HANDLE h = CreateFileA(p, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);\n",
+    "        if (h != INVALID_HANDLE_VALUE) {\n",
+    "            LARGE_INTEGER sz; GetFileSizeEx(h, &sz);\n",
+    "            printf(\"  OK: %s (%.1f MB)\\n\", files[i], sz.QuadPart/1e6);\n",
+    "            if (sz.QuadPart < 1000000 && i==0) {\n",
+    "                char buf[200]={0}; DWORD r; ReadFile(h,buf,100,&r,NULL);\n",
+    "                if(strstr(buf,\"git-lfs\")) printf(\"  *** GIT LFS POINTER! Not real file! ***\\n\");\n",
+    "            }\n",
+    "            CloseHandle(h);\n",
+    "        } else {\n",
+    "            printf(\"  FAIL: %s (error %lu)\\n\", files[i], GetLastError());\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    printf(\"\\n=== TEST 2: DLL Loading ===\\n\");\n",
+    "    SetDllDirectoryA(dd);\n",
+    "    snprintf(p, sizeof(p), \"%s\\\\onnxruntime.dll\", dd);\n",
+    "    HMODULE hort = LoadLibraryA(p);\n",
+    "    printf(\"  onnxruntime.dll: %s\\n\", hort ? \"OK\" : \"FAIL\");\n",
+    "    snprintf(p, sizeof(p), \"%s\\\\oneocr.dll\", dd);\n",
+    "    HMODULE hmod = LoadLibraryA(p);\n",
+    "    printf(\"  oneocr.dll: %s\\n\", hmod ? \"OK\" : \"FAIL\");\n",
+    "    if (hmod) {\n",
+    "        const char* ex[] = {\"CreateOcrInitOptions\",\"CreateOcrPipeline\",\"RunOcrPipeline\",\"ReleaseOcrResult\",\"ReleaseOcrPipeline\",NULL};\n",
+    "        for(int i=0;ex[i];i++) printf(\"    %s: %s\\n\", ex[i], GetProcAddress(hmod,ex[i])?\"OK\":\"MISSING\");\n",
+    "    }\n",
+    "\n",
+    "    printf(\"\\n=== TEST 3: bcrypt AES-256-CFB ===\\n\");\n",
+    "    HMODULE hbc = LoadLibraryA(\"bcrypt.dll\");\n",
+    "    if (!hbc) { printf(\"  FAIL: bcrypt.dll not loaded\\n\"); }\n",
+    "    else {\n",
+    "        fn_Open pO=(fn_Open)GetProcAddress(hbc,\"BCryptOpenAlgorithmProvider\");\n",
+    "        fn_SetP pS=(fn_SetP)GetProcAddress(hbc,\"BCryptSetProperty\");\n",
+    "        fn_GenK pG=(fn_GenK)GetProcAddress(hbc,\"BCryptGenerateSymmetricKey\");\n",
+    "        fn_Dec pD=(fn_Dec)GetProcAddress(hbc,\"BCryptDecrypt\");\n",
+    "        fn_Close pC=(fn_Close)GetProcAddress(hbc,\"BCryptCloseAlgorithmProvider\");\n",
+    "        fn_DestK pDK=(fn_DestK)GetProcAddress(hbc,\"BCryptDestroyKey\");\n",
+    "        BCRYPT_ALG_HANDLE hA=NULL;\n",
+    "        NTSTATUS st=pO(&hA,L\"AES\",NULL,0);\n",
+    "        printf(\"  OpenAlgorithm(AES): 0x%08lx %s\\n\",st,st==0?\"OK\":\"FAIL\");\n",
+    "        if(st==0){\n",
+    "            wchar_t cfb[]=L\"ChainingModeCFB\";\n",
+    "            st=pS(hA,L\"ChainingMode\",(unsigned char*)cfb,sizeof(cfb),0);\n",
+    "            printf(\"  SetProperty(CFB): 0x%08lx %s\\n\",st,st==0?\"OK\":\"FAIL\");\n",
+    "            if(st!=0){\n",
+    "                printf(\"  *** CFB NOT SUPPORTED! Trying others... ***\\n\");\n",
+    "                wchar_t cbc[]=L\"ChainingModeCBC\"; wchar_t ecb[]=L\"ChainingModeECB\"; wchar_t gcm[]=L\"ChainingModeGCM\";\n",
+    "                printf(\"  CBC: 0x%08lx\\n\",pS(hA,L\"ChainingMode\",(unsigned char*)cbc,sizeof(cbc),0));\n",
+    "                printf(\"  ECB: 0x%08lx\\n\",pS(hA,L\"ChainingMode\",(unsigned char*)ecb,sizeof(ecb),0));\n",
+    "                printf(\"  GCM: 0x%08lx\\n\",pS(hA,L\"ChainingMode\",(unsigned char*)gcm,sizeof(gcm),0));\n",
+    "            }\n",
+    "            if(st==0){\n",
+    "                unsigned char tk[32]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32};\n",
+    "                BCRYPT_KEY_HANDLE hK=NULL; st=pG(hA,&hK,NULL,0,tk,32,0);\n",
+    "                printf(\"  GenerateKey: 0x%08lx %s\\n\",st,st==0?\"OK\":\"FAIL\");\n",
+    "                if(st==0&&hK){\n",
+    "                    unsigned char iv[16]={0},ct[16]={65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80},pt[16]={0};\n",
+    "                    unsigned long cb=0; st=pD(hK,ct,16,NULL,iv,16,pt,16,&cb,0);\n",
+    "                    printf(\"  Decrypt: 0x%08lx %s (%lu bytes)\\n\",st,st==0?\"OK\":\"FAIL\",cb);\n",
+    "                    pDK(hK);\n",
+    "                }\n",
+    "            }\n",
+    "            pC(hA,0);\n",
+    "        }\n",
+    "        FreeLibrary(hbc);\n",
+    "    }\n",
+    "\n",
+    "    printf(\"\\n=== TEST 4: CreateOcrPipeline ===\\n\");\n",
+    "    if(!hmod){\n",
+    "        SetDllDirectoryA(dd);\n",
+    "        snprintf(p,sizeof(p),\"%s\\\\oneocr.dll\",dd);\n",
+    "        hmod=LoadLibraryA(p);\n",
+    "    }\n",
+    "    if(!hmod){printf(\"  SKIP: DLL not loaded\\n\");}\n",
+    "    else{\n",
+    "        fn_CrInit pCI=(fn_CrInit)GetProcAddress(hmod,\"CreateOcrInitOptions\");\n",
+    "        fn_SetDL pSD=(fn_SetDL)GetProcAddress(hmod,\"OcrInitOptionsSetUseModelDelayLoad\");\n",
+    "        fn_CrPipe pCP=(fn_CrPipe)GetProcAddress(hmod,\"CreateOcrPipeline\");\n",
+    "        fn_RelInit pRI=(fn_RelInit)GetProcAddress(hmod,\"ReleaseOcrInitOptions\");\n",
+    "        fn_RelPipe pRP=(fn_RelPipe)GetProcAddress(hmod,\"ReleaseOcrPipeline\");\n",
+    "        if(!pCI||!pCP){printf(\"  FAIL: Missing functions\\n\");}\n",
+    "        else{\n",
+    "            long long io=0,r2=pCI(&io);\n",
+    "            printf(\"  CreateOcrInitOptions: %lld %s\\n\",r2,r2==0?\"OK\":\"FAIL\");\n",
+    "            if(pSD){r2=pSD(io,1);printf(\"  SetDelayLoad(1): %lld %s\\n\",r2,r2==0?\"OK\":\"FAIL\");}\n",
+    "            snprintf(p,sizeof(p),\"%s\\\\oneocr.onemodel\",dd);\n",
+    "            int kl=(int)strlen(kh)/2; char key[64]={0};\n",
+    "            for(int i=0;i<kl&&i<63;i++) sscanf(kh+i*2,\"%2hhx\",(unsigned char*)&key[i]);\n",
+    "            printf(\"  Model: %s\\n  Key: %d bytes\\n\",p,kl);\n",
+    "            fflush(stdout);\n",
+    "            long long pipe=0;\n",
+    "            r2=pCP(p,key,io,&pipe);\n",
+    "            printf(\"  CreateOcrPipeline: %lld %s\\n\",r2,r2==0?\"OK\":\"FAIL\");\n",
+    "            if(r2==0){printf(\"  *** SUCCESS! Pipeline works under Wine! ***\\n\");pRP(pipe);}\n",
+    "            else{printf(\"  *** FAILED with code %lld ***\\n\",r2);}\n",
+    "            pRI(io);\n",
+    "        }\n",
+    "        FreeLibrary(hmod);\n",
+    "    }\n",
+    "    if(hort)FreeLibrary(hort);\n",
+    "    printf(\"\\n=== DONE ===\\n\");\n",
+    "    return 0;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "# Write and compile debug loader\n",
+    "with open('/tmp/oneocr_debug.c', 'w') as f:\n",
+    "    f.write(DEBUG_C)\n",
+    "\n",
+    "r = subprocess.run(\n",
+    "    ['x86_64-w64-mingw32-gcc', '-O2', '-o', '/tmp/oneocr_debug.exe', '/tmp/oneocr_debug.c'],\n",
+    "    capture_output=True, text=True\n",
+    ")\n",
+    "if r.returncode != 0:\n",
+    "    print(\"COMPILE ERROR (debug):\")\n",
+    "    print(r.stderr)\n",
+    "else:\n",
+    "    sz = os.path.getsize('/tmp/oneocr_debug.exe')\n",
+    "    print(f\"  OK: oneocr_debug.exe ({sz} bytes)\")\n",
+    "\n",
+    "# Also compile the main loader from repo (if source exists)\n",
+    "loader_c = '/content/oneocr/tools/oneocr_loader.c'\n",
+    "if os.path.exists(loader_c):\n",
+    "    r2 = subprocess.run(\n",
+    "        ['x86_64-w64-mingw32-gcc', '-O2', '-o', '/tmp/oneocr_loader.exe', loader_c],\n",
+    "        capture_output=True, text=True\n",
+    "    )\n",
+    "    if r2.returncode != 0:\n",
+    "        print(\"COMPILE ERROR (loader):\")\n",
+    "        print(r2.stderr)\n",
+    "    else:\n",
+    "        print(f\"  OK: oneocr_loader.exe ({os.path.getsize('/tmp/oneocr_loader.exe')} bytes)\")\n",
+    "else:\n",
+    "    print(f\"  SKIP: {loader_c} not found\")"
    ]
   },
   {
@@ -187,46 +309,47 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 7. 🔍 DIAGNOSTYKA — Run debug loader to find exact failure point\n",
+    "# 7. DIAGNOSTYKA - testuje kazdy komponent pod Wine osobno\n",
     "import subprocess, os\n",
     "\n",
     "os.environ['WINEDEBUG'] = '-all'\n",
+    "exe = '/tmp/oneocr_debug.exe'\n",
+    "dll_dir = 'Z:\\\\content\\\\oneocr\\\\ocr_data'\n",
     "\n",
-    "# Convert path for Wine\n",
-    "dll_dir_wine = 'Z:\\\\content\\\\oneocr\\\\ocr_data'\n",
-    "\n",
-    "print(\"=\" * 60)\n",
-    "print(\"DIAGNOSTYKA: Testowanie komponentów pod Wine\")\n",
-    "print(\"=\" * 60)\n",
-    "\n",
-    "# Run debug loader\n",
-    "result = subprocess.run(\n",
-    "    ['wine64', '/content/oneocr/tools/oneocr_debug.exe', dll_dir_wine],\n",
-    "    capture_output=True, text=True, timeout=120,\n",
-    "    env={**os.environ, 'WINEDEBUG': '-all'}\n",
-    ")\n",
-    "\n",
-    "print(result.stdout)\n",
-    "if result.stderr:\n",
-    "    print(\"--- STDERR ---\")\n",
-    "    print(result.stderr[:1000])\n",
-    "\n",
-    "# Also run with Wine debug channels for bcrypt/ntdll\n",
-    "print(\"\\n\" + \"=\" * 60)\n",
-    "print(\"EXTRA: Wine debug trace (bcrypt + module loading)\")\n",
-    "print(\"=\" * 60)\n",
-    "result2 = subprocess.run(\n",
-    "    ['wine64', '/content/oneocr/tools/oneocr_debug.exe', dll_dir_wine],\n",
-    "    capture_output=True, text=True, timeout=120,\n",
-    "    env={**os.environ, 'WINEDEBUG': '+bcrypt,+loaddll'}\n",
-    ")\n",
-    "# Only show relevant debug lines (not all the noise)\n",
-    "for line in result2.stderr.split('\\n'):\n",
-    "    if any(kw in line.lower() for kw in ['bcrypt', 'cfb', 'fail', 'err:', 'fixme:', 'oneocr', 'onnxruntime', 'not implemented', 'not supported']):\n",
-    "        print(line)\n",
-    "if result2.stdout != result.stdout:\n",
-    "    print(\"\\nDiagnostic output:\")\n",
-    "    print(result2.stdout[-500:])"
+    "# Verify exe exists\n",
+    "if not os.path.exists(exe):\n",
+    "    print(f\"BLAD: {exe} nie istnieje! Uruchom komorke 6 najpierw.\")\n",
+    "else:\n",
+    "    print(f\"EXE: {exe} ({os.path.getsize(exe)} bytes)\")\n",
+    "    print(f\"DLL dir: {dll_dir}\")\n",
+    "    print(\"=\" * 60)\n",
+    "\n",
+    "    # Run diagnostic\n",
+    "    result = subprocess.run(\n",
+    "        ['wine64', exe, dll_dir],\n",
+    "        capture_output=True, text=True, timeout=120,\n",
+    "        env={**os.environ, 'WINEDEBUG': '-all'}\n",
+    "    )\n",
+    "\n",
+    "    if result.stdout:\n",
+    "        print(result.stdout)\n",
+    "    if result.stderr:\n",
+    "        print(\"--- WINE STDERR ---\")\n",
+    "        print(result.stderr[:2000])\n",
+    "\n",
+    "    # Second run with Wine debug channels\n",
+    "    print(\"\\n\" + \"=\" * 60)\n",
+    "    print(\"Wine debug trace (bcrypt + loaddll):\")\n",
+    "    print(\"=\" * 60)\n",
+    "    r2 = subprocess.run(\n",
+    "        ['wine64', exe, dll_dir],\n",
+    "        capture_output=True, text=True, timeout=120,\n",
+    "        env={**os.environ, 'WINEDEBUG': '+bcrypt,+loaddll,-other'}\n",
+    "    )\n",
+    "    for line in r2.stderr.split('\\n'):\n",
+    "        lo = line.lower()\n",
+    "        if any(k in lo for k in ['bcrypt','cfb','fail','err:','fixme:','oneocr','onnxruntime','not impl','not supp']):\n",
+    "            print(line[:200])"
    ]
   },
   {
@@ -236,48 +359,41 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 8. 🧪 TEST: Run C loader via Wine on a single image\n",
+    "# 8. TEST: Single image OCR via Wine\n",
     "import subprocess, json, os\n",
     "from PIL import Image\n",
     "from pathlib import Path\n",
     "\n",
     "os.environ['WINEDEBUG'] = '-all'\n",
     "\n",
-    "# Convert test image to BMP\n",
     "test_img = '/content/oneocr/working_space/input/ocr_test (1).png'\n",
     "bmp_path = '/tmp/test.bmp'\n",
     "img = Image.open(test_img).convert('RGBA')\n",
     "img.save(bmp_path, format='BMP')\n",
     "print(f'Image: {img.size}')\n",
     "\n",
-    "# Model key\n",
     "key = b'kj)TGtrK>f]b[Piow.gU+nC@s\\x22\\x22\\x22\\x22\\x22\\x224'\n",
     "key_hex = key.hex()\n",
     "\n",
-    "# Convert paths to Wine Z: format\n",
-    "dll_dir = 'Z:\\\\content\\\\oneocr\\\\ocr_data'\n",
-    "bmp_wine = 'Z:\\\\tmp\\\\test.bmp'\n",
-    "\n",
-    "cmd = ['wine64', '/content/oneocr/tools/oneocr_loader.exe', dll_dir, bmp_wine, key_hex]\n",
-    "print(f'Running: wine64 oneocr_loader.exe ...')\n",
-    "\n",
-    "result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)\n",
+    "result = subprocess.run(\n",
+    "    ['wine64', '/tmp/oneocr_loader.exe',\n",
+    "     'Z:\\\\content\\\\oneocr\\\\ocr_data', 'Z:\\\\tmp\\\\test.bmp', key_hex],\n",
+    "    capture_output=True, text=True, timeout=120,\n",
+    "    env={**os.environ, 'WINEDEBUG': '-all'}\n",
+    ")\n",
     "\n",
     "print(f'Return code: {result.returncode}')\n",
-    "if result.stderr:\n",
-    "    print(f'Stderr: {result.stderr[:500]}')\n",
-    "\n",
     "if result.returncode == 0 and result.stdout.strip():\n",
     "    data = json.loads(result.stdout.strip())\n",
-    "    print(f'\\n✅ SUCCESS!')\n",
-    "    print(f'Text angle: {data[\"text_angle\"]}')\n",
+    "    print(f'\\nSUCCESS!')\n",
     "    for line in data['lines']:\n",
     "        words = ' | '.join(f\"{w['text']} ({w['confidence']:.0%})\" for w in line['words'])\n",
-    "        print(f'  Line: {words}')\n",
-    "    print(f'\\nTotal lines: {len(data[\"lines\"])}')\n",
+    "        print(f'  {words}')\n",
+    "    print(f'Total lines: {len(data[\"lines\"])}')\n",
     "else:\n",
-    "    print('❌ FAILED')\n",
-    "    print(result.stdout[:500] if result.stdout else 'No stdout')"
+    "    print('FAILED')\n",
+    "    if result.stderr: print(f'Stderr: {result.stderr[:500]}')\n",
+    "    if result.stdout: print(f'Stdout: {result.stdout[:500]}')"
    ]
   },
   {
@@ -287,49 +403,43 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 9. 🧪 FULL TEST: Run on ALL 19 test images\n",
+    "# 9. FULL TEST: All 19 images\n",
     "import time\n",
     "\n",
     "test_dir = Path('/content/oneocr/working_space/input')\n",
     "images = sorted(test_dir.glob('*.png'))\n",
-    "print(f'Testing {len(images)} images via Wine bridge...\\n')\n",
+    "print(f'Testing {len(images)} images...\\n')\n",
     "\n",
-    "success = 0\n",
+    "ok = 0\n",
     "fail = 0\n",
-    "\n",
     "for img_path in images:\n",
     "    try:\n",
     "        img = Image.open(img_path).convert('RGBA')\n",
     "        img.save(bmp_path, format='BMP')\n",
-    "\n",
     "        t0 = time.time()\n",
-    "        result = subprocess.run(\n",
-    "            ['wine64', '/content/oneocr/tools/oneocr_loader.exe',\n",
+    "        r = subprocess.run(\n",
+    "            ['wine64', '/tmp/oneocr_loader.exe',\n",
     "             'Z:\\\\content\\\\oneocr\\\\ocr_data', 'Z:\\\\tmp\\\\test.bmp', key_hex],\n",
     "            capture_output=True, text=True, timeout=120,\n",
     "            env={**os.environ, 'WINEDEBUG': '-all'}\n",
     "        )\n",
     "        dt = time.time() - t0\n",
-    "\n",
-    "        if result.returncode == 0 and result.stdout.strip():\n",
-    "            data = json.loads(result.stdout.strip())\n",
-    "            n_lines = len(data['lines'])\n",
-    "            text = ' | '.join(l['text'] for l in data['lines'][:3])\n",
-    "            print(f'  ✅ {img_path.name:25s} | {dt:.1f}s | {n_lines}L | {text[:50]}')\n",
-    "            success += 1\n",
+    "        if r.returncode == 0 and r.stdout.strip():\n",
+    "            data = json.loads(r.stdout.strip())\n",
+    "            txt = ' | '.join(l['text'] for l in data['lines'][:3])\n",
+    "            print(f'  OK {img_path.name:25s} | {dt:.1f}s | {len(data[\"lines\"])}L | {txt[:60]}')\n",
+    "            ok += 1\n",
     "        else:\n",
-    "            print(f'  ❌ {img_path.name:25s} | {result.stderr[:100]}')\n",
+    "            print(f'  FAIL {img_path.name:25s} | {r.stderr[:80]}')\n",
     "            fail += 1\n",
     "    except Exception as e:\n",
-    "        print(f'  ❌ {img_path.name:25s} | {e}')\n",
+    "        print(f'  FAIL {img_path.name:25s} | {e}')\n",
     "        fail += 1\n",
     "\n",
-    "print(f'\\n{\"=\" * 60}')\n",
-    "print(f'Result: {success}/{success+fail} OK ({success/(success+fail)*100:.0f}%)')\n",
+    "print(f'\\n{\"=\"*60}')\n",
+    "print(f'Result: {ok}/{ok+fail} ({ok/(ok+fail)*100:.0f}%)')\n",
     "if fail == 0:\n",
-    "    print('🎉 Wine bridge on Linux: WORKS! 100% accuracy identical to Windows DLL.')\n",
-    "else:\n",
-    "    print(f'⚠️ {fail} failures — check diagnostic output (cell 7) for details')"
+    "    print('Wine bridge DZIALA! 100% taki sam wynik jak DLL na Windows.')"
    ]
   },
   {
@@ -339,22 +449,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# 10. 🧪 TEST: Unified engine (auto-selects Wine backend on Linux)\n",
+    "# 10. Unified engine test\n",
     "import sys\n",
     "sys.path.insert(0, '/content/oneocr')\n",
-    "\n",
     "from ocr.engine_unified import OcrEngineUnified\n",
     "\n",
     "engine = OcrEngineUnified()\n",
-    "print(f'Backend selected: {engine.backend_name}')\n",
+    "print(f'Backend: {engine.backend_name}')\n",
     "\n",
     "img = Image.open('/content/oneocr/working_space/input/ocr_test (10).png')\n",
     "result = engine.recognize_pil(img)\n",
-    "\n",
     "print(f'Text: {result.text}')\n",
     "print(f'Lines: {len(result.lines)}')\n",
-    "print(f'Confidence: {result.average_confidence:.1%}')\n",
-    "print(f'\\n🎉 OneOCR DLL works on Linux via Wine! Same 100% accuracy as Windows.')"
+    "print(f'Confidence: {result.average_confidence:.1%}')"
    ]
   }
  ],