Automating Purchase Order Verification with OCR + Product Matching

# ocr_processor.py
import pytesseract
from PIL import Image
import pdf2image
import cv2
import numpy as np
import re
from typing import List, Dict
 
class POProcessor:
    """
    Process purchase order documents with OCR
    
    Handles:
    - PDF and image formats
    - Image preprocessing (deskew, denoise, contrast)
    - Text extraction with Tesseract
    - Line item parsing with regex
    """
    
    def __init__(self):
        # Configure Tesseract for better accuracy
        self.tesseract_config = '--oem 3 --psm 6'  # LSTM engine, assume uniform block of text
        
        # Regex patterns for common PO formats
        self.patterns = {
            'item_code': r'[A-Z0-9]{4,12}',  # Product codes
            'quantity': r'\b\d+\b',  # Quantities
            'price': r'\$?\d+\.?\d{0,2}',  # Prices
            'description': r'[A-Za-z0-9\s\-,\.]{10,100}'  # Product descriptions
        }
    
    def process_document(self, file_path: str) -> Dict:
        """
        Process uploaded PO document
        
        Returns:
            {
                'line_items': List of extracted items,
                'raw_text': Full OCR text,
                'confidence': Average OCR confidence
            }
        """
        # Detect file type
        if file_path.lower().endswith('.pdf'):
            images = self._pdf_to_images(file_path)
        else:
            images = [Image.open(file_path)]
        
        all_line_items = []
        raw_texts = []
        confidences = []
        
        # Process each page
        for img in images:
            # Preprocess image
            processed_img = self._preprocess_image(img)
            
            # Extract text with confidence
            ocr_data = pytesseract.image_to_data(
                processed_img,
                config=self.tesseract_config,
                output_type=pytesseract.Output.DICT
            )
            
            # Get full text
            text = pytesseract.image_to_string(processed_img, config=self.tesseract_config)
            raw_texts.append(text)
            
            # Calculate average confidence
            confidences.extend([c for c in ocr_data['conf'] if c != -1])
            
            # Parse line items from text
            line_items = self._parse_line_items(text)
            all_line_items.extend(line_items)
        
        avg_confidence = np.mean(confidences) if confidences else 0
        
        return {
            'line_items': all_line_items,
            'raw_text': '\n\n'.join(raw_texts),
            'confidence': avg_confidence,
            'num_pages': len(images)
        }
    
    def _pdf_to_images(self, pdf_path: str) -> List[Image.Image]:
        """Convert PDF to images for OCR"""
        images = pdf2image.convert_from_path(
            pdf_path,
            dpi=300,  # High DPI for better OCR accuracy
            fmt='png'
        )
        return images
    
    def _preprocess_image(self, img: Image.Image) -> np.ndarray:
        """
        Preprocess image for better OCR accuracy
        
        Steps:
        1. Convert to grayscale
        2. Deskew (straighten rotated images)
        3. Denoise
        4. Enhance contrast
        5. Binarize (threshold to black/white)
        """
        # Convert PIL to OpenCV format
        img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
        
        # Convert to grayscale
        gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
        
        # Deskew
        coords = np.column_stack(np.where(gray > 0))
        angle = cv2.minAreaRect(coords)[-1]
        if angle < -45:
            angle = -(90 + angle)
        else:
            angle = -angle
        
        (h, w) = gray.shape[:2]
        center = (w // 2, h // 2)
        M = cv2.getRotationMatrix2D(center, angle, 1.0)
        gray = cv2.warpAffine(gray, M, (w, h), 
                              flags=cv2.INTER_CUBIC, 
                              borderMode=cv2.BORDER_REPLICATE)
        
        # Denoise
        denoised = cv2.fastNlMeansDenoising(gray, None, 10, 7, 21)
        
        # Enhance contrast with CLAHE
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
        enhanced = clahe.apply(denoised)
        
        # Binarize with adaptive threshold
        binary = cv2.adaptiveThreshold(
            enhanced,
            255,
            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY,
            11,
            2
        )
        
        return binary
    
    def _parse_line_items(self, text: str) -> List[Dict]:
        """
        Parse line items from OCR text
        
        Looks for patterns like:
        - Item code + description + quantity + price
        - Separated by lines or tables
        """
        lines = text.split('\n')
        line_items = []
        
        for line in lines:
            # Skip empty lines
            if not line.strip():
                continue
            
            # Try to extract structured data
            item = self._extract_item_from_line(line)
            if item:
                line_items.append(item)
        
        return line_items
    
    def _extract_item_from_line(self, line: str) -> Dict:
        """
        Extract structured item data from a single line
        
        Returns:
            {
                'item_code': str,
                'description': str,
                'quantity': int,
                'unit_price': float,
                'raw_line': str
            }
        """
        # Look for item code
        item_code_match = re.search(self.patterns['item_code'], line)
        if not item_code_match:
            return None
        
        item_code = item_code_match.group(0)
        
        # Look for quantity
        quantity_matches = re.findall(self.patterns['quantity'], line)
        quantity = int(quantity_matches[0]) if quantity_matches else 1
        
        # Look for price
        price_matches = re.findall(self.patterns['price'], line)
        unit_price = 0.0
        if price_matches:
            price_str = price_matches[0].replace('$', '')
            try:
                unit_price = float(price_str)
            except ValueError:
                pass
        
        # Extract description (everything between item code and price)
        description = line.replace(item_code, '', 1)
        if price_matches:
            description = description.replace(price_matches[0], '', 1)
        description = description.strip()
        
        # Clean description
        description = re.sub(r'\s+', ' ', description)  # Remove extra spaces
        description = description[:100]  # Limit length
        
        return {
            'item_code': item_code,
            'description': description,
            'quantity': quantity,
            'unit_price': unit_price,
            'raw_line': line.strip()
        }
 
# Usage
processor = POProcessor()
result = processor.process_document('purchase_order.pdf')
 
print(f"Extracted {len(result['line_items'])} line items")
print(f"OCR Confidence: {result['confidence']:.1f}%")
 
for item in result['line_items']:
    print(f"  {item['item_code']} - {item['description']} (Qty: {item['quantity']})")

# product_matcher.py
from fuzzywuzzy import fuzz
from typing import List, Dict, Tuple
import psycopg2
from psycopg2.extras import RealDictCursor
 
class ProductMatcher:
    """
    Match extracted line items to product catalog
    
    Uses:
    - Exact item code matching (highest priority)
    - Fuzzy string matching on descriptions
    - PostgreSQL full-text search
    - Metadata matching (category, brand, etc.)
    """
    
    def __init__(self, db_config: Dict):
        self.conn = psycopg2.connect(**db_config)
        self.min_match_score = 70  # Minimum fuzzy match score (0-100)
    
    def match_line_items(
        self,
        line_items: List[Dict],
        top_k: int = 5
    ) -> List[Dict]:
        """
        Match each line item to products in catalog
        
        Returns:
            List of line items with top K product matches
        """
        matched_items = []
        
        for item in line_items:
            # Try exact item code match first
            exact_match = self._exact_code_match(item['item_code'])
            
            if exact_match:
                matches = [{'product': exact_match, 'score': 100, 'method': 'exact'}]
            else:
                # Fall back to fuzzy matching
                matches = self._fuzzy_match(
                    item['description'],
                    item['item_code'],
                    top_k=top_k
                )
            
            matched_items.append({
                **item,
                'matches': matches,
                'best_match': matches[0] if matches else None
            })
        
        return matched_items
    
    def _exact_code_match(self, item_code: str) -> Dict:
        """Try to find exact match by item code"""
        with self.conn.cursor(cursor_factory=RealDictCursor) as cur:
            cur.execute("""
                SELECT id, item_code, name, description, category, unit_price
                FROM products
                WHERE item_code = %s
                LIMIT 1
            """, (item_code,))
            
            return cur.fetchone()
    
    def _fuzzy_match(
        self,
        description: str,
        item_code: str,
        top_k: int = 5
    ) -> List[Dict]:
        """
        Find best matches using fuzzy string matching
        
        Combines:
        1. PostgreSQL full-text search (fast, broad recall)
        2. Fuzzy string similarity (accurate, slow)
        3. Item code partial matching
        """
        # Step 1: Get candidates using full-text search
        candidates = self._fulltext_search(description, limit=50)
        
        # Step 2: Score each candidate with fuzzy matching
        scored_candidates = []
        
        for candidate in candidates:
            # Calculate multiple similarity scores
            desc_score = fuzz.token_sort_ratio(
                description.lower(),
                candidate['description'].lower()
            )
            
            name_score = fuzz.token_sort_ratio(
                description.lower(),
                candidate['name'].lower()
            )
            
            # Partial item code match
            code_score = fuzz.partial_ratio(
                item_code,
                candidate['item_code']
            )
            
            # Weighted average
            final_score = (
                desc_score * 0.5 +
                name_score * 0.3 +
                code_score * 0.2
            )
            
            if final_score >= self.min_match_score:
                scored_candidates.append({
                    'product': candidate,
                    'score': final_score,
                    'method': 'fuzzy',
                    'scores': {
                        'description': desc_score,
                        'name': name_score,
                        'code': code_score
                    }
                })
        
        # Sort by score and return top K
        scored_candidates.sort(key=lambda x: x['score'], reverse=True)
        return scored_candidates[:top_k]
    
    def _fulltext_search(self, query: str, limit: int = 50) -> List[Dict]:
        """
        Use PostgreSQL full-text search for fast candidate retrieval
        
        Creates tsvector index on product descriptions for speed
        """
        with self.conn.cursor(cursor_factory=RealDictCursor) as cur:
            # Full-text search with ranking
            cur.execute("""
                SELECT 
                    id,
                    item_code,
                    name,
                    description,
                    category,
                    unit_price,
                    ts_rank(search_vector, query) as rank
                FROM products,
                     plainto_tsquery('english', %s) query
                WHERE search_vector @@ query
                ORDER BY rank DESC
                LIMIT %s
            """, (query, limit))
            
            return cur.fetchall()
    
    def save_verified_matches(
        self,
        purchase_order_id: int,
        verified_matches: List[Dict]
    ):
        """
        Save user-verified matches to database
        
        Args:
            verified_matches: List of {line_item_id, product_id, quantity, unit_price}
        """
        with self.conn.cursor() as cur:
            for match in verified_matches:
                cur.execute("""
                    INSERT INTO matches (
                        purchase_order_id,
                        line_item_id,
                        product_id,
                        quantity,
                        unit_price,
                        verified_at
                    ) VALUES (
                        %s, %s, %s, %s, %s, NOW()
                    )
                """, (
                    purchase_order_id,
                    match['line_item_id'],
                    match['product_id'],
                    match['quantity'],
                    match['unit_price']
                ))
            
            self.conn.commit()
 
# Usage
matcher = ProductMatcher(db_config={
    'host': 'localhost',
    'database': 'po_processing',
    'user': 'postgres',
    'password': 'password'
})
 
# Match extracted line items
matched_items = matcher.match_line_items(line_items, top_k=5)
 
# Display matches for verification
for item in matched_items:
    print(f"\nLine: {item['description']}")
    print(f"Best match: {item['best_match']['product']['name']} "
          f"(score: {item['best_match']['score']:.1f})")

-- schema.sql
 
-- Product catalog
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    item_code VARCHAR(50) UNIQUE NOT NULL,
    name VARCHAR(200) NOT NULL,
    description TEXT,
    category VARCHAR(100),
    brand VARCHAR(100),
    unit_price DECIMAL(10, 2),
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);
 
-- Full-text search index
ALTER TABLE products ADD COLUMN search_vector tsvector;
 
CREATE INDEX products_search_idx ON products USING gin(search_vector);
 
-- Trigger to update search vector automatically
CREATE OR REPLACE FUNCTION products_search_trigger() RETURNS trigger AS $$
BEGIN
    NEW.search_vector :=
        setweight(to_tsvector('english', coalesce(NEW.name, '')), 'A') ||
        setweight(to_tsvector('english', coalesce(NEW.description, '')), 'B') ||
        setweight(to_tsvector('english', coalesce(NEW.item_code, '')), 'C');
    RETURN NEW;
END
$$ LANGUAGE plpgsql;
 
CREATE TRIGGER products_search_update BEFORE INSERT OR UPDATE
    ON products FOR EACH ROW EXECUTE FUNCTION products_search_trigger();
 
-- Purchase orders
CREATE TABLE purchase_orders (
    id SERIAL PRIMARY KEY,
    file_path VARCHAR(500),
    file_type VARCHAR(20),
    raw_text TEXT,
    ocr_confidence DECIMAL(5, 2),
    status VARCHAR(50) DEFAULT 'pending',
    uploaded_by VARCHAR(100),
    created_at TIMESTAMP DEFAULT NOW()
);
 
-- Extracted line items
CREATE TABLE line_items (
    id SERIAL PRIMARY KEY,
    purchase_order_id INTEGER REFERENCES purchase_orders(id),
    item_code VARCHAR(50),
    description TEXT,
    quantity INTEGER,
    unit_price DECIMAL(10, 2),
    raw_line TEXT,
    created_at TIMESTAMP DEFAULT NOW()
);
 
-- Verified matches
CREATE TABLE matches (
    id SERIAL PRIMARY KEY,
    purchase_order_id INTEGER REFERENCES purchase_orders(id),
    line_item_id INTEGER REFERENCES line_items(id),
    product_id INTEGER REFERENCES products(id),
    quantity INTEGER,
    unit_price DECIMAL(10, 2),
    verified_at TIMESTAMP DEFAULT NOW(),
    verified_by VARCHAR(100)
);
 
-- Indexes for performance
CREATE INDEX idx_po_status ON purchase_orders(status);
CREATE INDEX idx_line_items_po ON line_items(purchase_order_id);
CREATE INDEX idx_matches_po ON matches(purchase_order_id);

# app.py
from flask import Flask, request, jsonify, send_file
from flask_cors import CORS
import os
from werkzeug.utils import secure_filename
import psycopg2
 
from ocr_processor import POProcessor
from product_matcher import ProductMatcher
 
app = Flask(__name__)
CORS(app)
 
# Configuration
UPLOAD_FOLDER = 'uploads'
ALLOWED_EXTENSIONS = {'pdf', 'png', 'jpg', 'jpeg'}
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
 
# Database config
DB_CONFIG = {
    'host': os.getenv('DB_HOST', 'localhost'),
    'database': os.getenv('DB_NAME', 'po_processing'),
    'user': os.getenv('DB_USER', 'postgres'),
    'password': os.getenv('DB_PASSWORD', 'password')
}
 
# Initialize processors
ocr_processor = POProcessor()
product_matcher = ProductMatcher(DB_CONFIG)
 
def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
@app.route('/api/upload', methods=['POST'])
def upload_po():
    """
    Upload and process purchase order
    
    Request:
        - file: PO document (PDF/image)
    
    Response:
        {
            'success': True,
            'po_id': 123,
            'line_items': [...],
            'ocr_confidence': 85.3
        }
    """
    try:
        # Check file
        if 'file' not in request.files:
            return jsonify({'error': 'No file uploaded'}), 400
        
        file = request.files['file']
        
        if file.filename == '':
            return jsonify({'error': 'Empty filename'}), 400
        
        if not allowed_file(file.filename):
            return jsonify({'error': 'Invalid file type'}), 400
        
        # Save file
        filename = secure_filename(file.filename)
        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        file.save(filepath)
        
        # Process with OCR
        result = ocr_processor.process_document(filepath)
        
        # Save to database
        conn = psycopg2.connect(**DB_CONFIG)
        cur = conn.cursor()
        
        # Insert PO
        cur.execute("""
            INSERT INTO purchase_orders (file_path, file_type, raw_text, ocr_confidence, status)
            VALUES (%s, %s, %s, %s, 'processing')
            RETURNING id
        """, (filepath, filename.rsplit('.', 1)[1], result['raw_text'], result['confidence']))
        
        po_id = cur.fetchone()[0]
        
        # Insert line items
        line_item_ids = []
        for item in result['line_items']:
            cur.execute("""
                INSERT INTO line_items (
                    purchase_order_id, item_code, description, quantity, unit_price, raw_line
                )
                VALUES (%s, %s, %s, %s, %s, %s)
                RETURNING id
            """, (
                po_id,
                item['item_code'],
                item['description'],
                item['quantity'],
                item['unit_price'],
                item['raw_line']
            ))
            line_item_ids.append(cur.fetchone()[0])
        
        conn.commit()
        cur.close()
        conn.close()
        
        # Match products
        matched_items = product_matcher.match_line_items(result['line_items'], top_k=5)
        
        # Add line item IDs
        for i, item in enumerate(matched_items):
            item['line_item_id'] = line_item_ids[i]
        
        return jsonify({
            'success': True,
            'po_id': po_id,
            'line_items': matched_items,
            'ocr_confidence': result['confidence'],
            'num_items': len(matched_items)
        })
        
    except Exception as e:
        print(f"Error processing upload: {e}")
        return jsonify({'error': str(e)}), 500
 
@app.route('/api/verify', methods=['POST'])
def verify_matches():
    """
    Save user-verified matches
    
    Request:
        {
            'po_id': 123,
            'matches': [
                {'line_item_id': 1, 'product_id': 456, 'quantity': 10, 'unit_price': 29.99},
                ...
            ]
        }
    """
    try:
        data = request.json
        po_id = data['po_id']
        matches = data['matches']
        
        # Save verified matches
        product_matcher.save_verified_matches(po_id, matches)
        
        # Update PO status
        conn = psycopg2.connect(**DB_CONFIG)
        cur = conn.cursor()
        cur.execute("""
            UPDATE purchase_orders
            SET status = 'completed'
            WHERE id = %s
        """, (po_id,))
        conn.commit()
        cur.close()
        conn.close()
        
        return jsonify({
            'success': True,
            'message': f'Saved {len(matches)} verified matches'
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500
 
@app.route('/api/products/search', methods=['GET'])
def search_products():
    """
    Search product catalog
    
    Query params:
        - q: Search query
        - limit: Max results (default 20)
    """
    try:
        query = request.args.get('q', '')
        limit = int(request.args.get('limit', 20))
        
        conn = psycopg2.connect(**DB_CONFIG)
        cur = conn.cursor()
        
        cur.execute("""
            SELECT id, item_code, name, description, category, unit_price
            FROM products
            WHERE search_vector @@ plainto_tsquery('english', %s)
            ORDER BY ts_rank(search_vector, plainto_tsquery('english', %s)) DESC
            LIMIT %s
        """, (query, query, limit))
        
        products = []
        for row in cur.fetchall():
            products.append({
                'id': row[0],
                'item_code': row[1],
                'name': row[2],
                'description': row[3],
                'category': row[4],
                'unit_price': float(row[5])
            })
        
        cur.close()
        conn.close()
        
        return jsonify({'products': products})
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500
 
@app.route('/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy'})
 
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

// App.tsx
import React, { useState } from 'react';
import axios from 'axios';
import { Upload, Check, X, Search } from 'lucide-react';
 
interface LineItem {
  line_item_id: number;
  item_code: string;
  description: string;
  quantity: number;
  unit_price: number;
  matches: ProductMatch[];
  best_match?: ProductMatch;
}
 
interface ProductMatch {
  product: Product;
  score: number;
  method: string;
}
 
interface Product {
  id: number;
  item_code: string;
  name: string;
  description: string;
  category: string;
  unit_price: number;
}
 
export const POProcessingApp: React.FC = () => {
  const [file, setFile] = useState<File | null>(null);
  const [loading, setLoading] = useState(false);
  const [poId, setPoId] = useState<number | null>(null);
  const [lineItems, setLineItems] = useState<LineItem[]>([]);
  const [ocrConfidence, setOcrConfidence] = useState<number>(0);
  const [selectedMatches, setSelectedMatches] = useState<Map<number, number>>(new Map());
 
  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const selectedFile = e.target.files?.[0];
    if (!selectedFile) return;
 
    setFile(selectedFile);
    setLoading(true);
 
    try {
      const formData = new FormData();
      formData.append('file', selectedFile);
 
      const response = await axios.post('http://localhost:5000/api/upload', formData, {
        headers: { 'Content-Type': 'multipart/form-data' }
      });
 
      if (response.data.success) {
        setPoId(response.data.po_id);
        setLineItems(response.data.line_items);
        setOcrConfidence(response.data.ocr_confidence);
 
        // Pre-select best matches
        const preselected = new Map();
        response.data.line_items.forEach((item: LineItem) => {
          if (item.best_match) {
            preselected.set(item.line_item_id, item.best_match.product.id);
          }
        });
        setSelectedMatches(preselected);
      }
    } catch (error) {
      console.error('Upload failed:', error);
      alert('Failed to process PO. Please try again.');
    } finally {
      setLoading(false);
    }
  };
 
  const handleMatchChange = (lineItemId: number, productId: number) => {
    setSelectedMatches(prev => new Map(prev).set(lineItemId, productId));
  };
 
  const handleVerify = async () => {
    if (!poId) return;
 
    setLoading(true);
 
    try {
      const matches = lineItems.map(item => ({
        line_item_id: item.line_item_id,
        product_id: selectedMatches.get(item.line_item_id)!,
        quantity: item.quantity,
        unit_price: item.unit_price
      }));
 
      await axios.post('http://localhost:5000/api/verify', {
        po_id: poId,
        matches
      });
 
      alert(`Successfully verified ${matches.length} line items!`);
 
      // Reset
      setFile(null);
      setPoId(null);
      setLineItems([]);
      setSelectedMatches(new Map());
    } catch (error) {
      console.error('Verification failed:', error);
      alert('Failed to save matches. Please try again.');
    } finally {
      setLoading(false);
    }
  };
 
  return (
    <div className="min-h-screen bg-gray-50 p-8">
      <div className="max-w-6xl mx-auto">
        <h1 className="text-3xl font-bold text-gray-900 mb-8">
          Purchase Order Processing
        </h1>
 
        {/* Upload Section */}
        {!poId && (
          <div className="bg-white rounded-lg shadow p-6 mb-8">
            <h2 className="text-xl font-semibold mb-4">Upload Purchase Order</h2>
            
            <div className="border-2 border-dashed border-gray-300 rounded-lg p-12 text-center">
              <Upload className="mx-auto h-12 w-12 text-gray-400 mb-4" />
              <p className="text-gray-600 mb-4">
                Drag and drop your PO or click to browse
              </p>
              <input
                type="file"
                accept=".pdf,.png,.jpg,.jpeg"
                onChange={handleFileUpload}
                className="hidden"
                id="file-upload"
              />
              <label
                htmlFor="file-upload"
                className="bg-blue-600 text-white px-6 py-2 rounded-lg cursor-pointer hover:bg-blue-700"
              >
                Select File
              </label>
              {file && (
                <p className="mt-4 text-sm text-gray-600">
                  Selected: {file.name}
                </p>
              )}
            </div>
 
            {loading && (
              <div className="mt-4 text-center">
                <div className="inline-block animate-spin rounded-full h-8 w-8 border-4 border-blue-600 border-t-transparent"></div>
                <p className="mt-2 text-gray-600">Processing OCR...</p>
              </div>
            )}
          </div>
        )}
 
        {/* Results Section */}
        {poId && lineItems.length > 0 && (
          <div className="bg-white rounded-lg shadow p-6">
            <div className="flex items-center justify-between mb-6">
              <div>
                <h2 className="text-xl font-semibold">Review Matches</h2>
                <p className="text-sm text-gray-600 mt-1">
                  OCR Confidence: {ocrConfidence.toFixed(1)}% | 
                  {lineItems.length} items extracted
                </p>
              </div>
              <button
                onClick={handleVerify}
                disabled={loading}
                className="bg-green-600 text-white px-6 py-2 rounded-lg hover:bg-green-700 flex items-center gap-2"
              >
                <Check className="h-5 w-5" />
                Verify & Save
              </button>
            </div>
 
            <div className="space-y-4">
              {lineItems.map((item) => (
                <div key={item.line_item_id} className="border rounded-lg p-4">
                  <div className="grid grid-cols-2 gap-4">
                    {/* Extracted Item */}
                    <div>
                      <h3 className="font-semibold text-sm text-gray-700 mb-2">
                        Extracted from PO
                      </h3>
                      <p className="text-sm">
                        <span className="font-medium">Code:</span> {item.item_code}
                      </p>
                      <p className="text-sm">
                        <span className="font-medium">Description:</span> {item.description}
                      </p>
                      <p className="text-sm">
                        <span className="font-medium">Qty:</span> {item.quantity} | 
                        <span className="font-medium"> Price:</span> ${item.unit_price.toFixed(2)}
                      </p>
                    </div>
 
                    {/* Matched Product */}
                    <div>
                      <h3 className="font-semibold text-sm text-gray-700 mb-2">
                        Matched Product
                        {item.best_match && (
                          <span className="ml-2 text-xs text-green-600">
                            ({item.best_match.score.toFixed(0)}% match)
                          </span>
                        )}
                      </h3>
                      
                      <select
                        value={selectedMatches.get(item.line_item_id) || ''}
                        onChange={(e) => handleMatchChange(item.line_item_id, parseInt(e.target.value))}
                        className="w-full border rounded px-3 py-2 text-sm"
                      >
                        {item.matches.map((match) => (
                          <option key={match.product.id} value={match.product.id}>
                            {match.product.item_code} - {match.product.name} 
                            ({match.score.toFixed(0)}%)
                          </option>
                        ))}
                      </select>
 
                      {selectedMatches.get(item.line_item_id) && (
                        <div className="mt-2 text-xs text-gray-600">
                          {item.matches.find(m => m.product.id === selectedMatches.get(item.line_item_id))?.product.description}
                        </div>
                      )}
                    </div>
                  </div>
                </div>
              ))}
            </div>
          </div>
        )}
      </div>
    </div>
  );
};

def preprocess_image(img):
    # Deskew → Denoise → Enhance contrast → Binarize
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    denoised = cv2.fastNlMeansDenoising(gray)
    clahe = cv2.createCLAHE(clipLimit=2.0)
    enhanced = clahe.apply(denoised)
    binary = cv2.adaptiveThreshold(enhanced, 255, 
                                   cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY, 11, 2)
    return binary

from transformers import LayoutLMv3ForTokenClassification
 
# Use LayoutLM to understand document structure
model = LayoutLMv3ForTokenClassification.from_pretrained('microsoft/layoutlmv3-base')
 
# Identify table cells, headers, line items
layout = model.predict(image, text)

# When user selects different match
if user_selected != ai_suggested:
    # Store correction
    save_correction(
        extracted_description=item['description'],
        correct_product_id=user_selected,
        ai_score=ai_suggested_score
    )
    
    # Retrain fuzzy matcher weights
    retrain_matcher()

from googletrans import Translator
 
def translate_description(text, source_lang):
    translator = Translator()
    translated = translator.translate(text, src=source_lang, dest='en')
    return translated.text
 
# Match in English, display in original language

def push_to_erp(verified_matches):
    erp_client = SAPClient(api_key=os.getenv('SAP_KEY'))
    
    for match in verified_matches:
        erp_client.create_purchase_order_line(
            product_id=match['product_id'],
            quantity=match['quantity'],
            unit_price=match['unit_price']
        )