Sarabjit Singh Dhaliwal

// Process images in chunks to keep UI responsive
async function processBatch(images, batchSize = 5) {
  const results = [];

  for (let i = 0; i < images.length; i += batchSize) {
    const batch = images.slice(i, i + batchSize);

    // Process batch in parallel
    const batchResults = await Promise.all(
      batch.map(img => resizeImage(img))
    );

    results.push(...batchResults);

    // Update progress without blocking UI
    updateProgress(i / images.length);
  }

  return results;
}

// Canvas-based resizing with quality control
function resizeImage(file, maxWidth = 1920) {
  return new Promise((resolve) => {
    const img = new Image();
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');

    img.onload = () => {
      const scale = maxWidth / img.width;
      canvas.width = img.width * scale;
      canvas.height = img.height * scale;

      // High-quality downscaling
      ctx.imageSmoothingEnabled = true;
      ctx.imageSmoothingQuality = 'high';
      ctx.drawImage(img, 0, 0, canvas.width, canvas.height);

      canvas.toBlob(resolve, 'image/jpeg', 0.85);
    };

    img.src = URL.createObjectURL(file);
  });
}

// Stream Claude API response for real-time writing
async function streamCompletion(prompt, onChunk) {
  const response = await fetch('/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'claude-3-5-sonnet-20241022',
      prompt,
      stream: true,
      max_tokens: 4096
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let fullText = '';

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    const chunk = decoder.decode(value);
    const lines = chunk.split('\n').filter(line => line.trim());

    for (const line of lines) {
      if (line.startsWith('data: ')) {
        const data = JSON.parse(line.slice(6));
        if (data.delta_text) {
          fullText += data.delta_text;
          onChunk(fullText); // Update UI in real-time
        }
      }
    }
  }

  return fullText;
}

// Parallel PDF page rendering
async function convertPDF(pdfFile, concurrency = 4) {
  const pdf = await pdfjsLib.getDocument(pdfFile).promise;
  const pages = await Promise.all(
    Array.from({ length: pdf.numPages }, (_, i) => pdf.getPage(i + 1))
  );

  // Process pages in parallel batches
  const results = [];

  for (let i = 0; i < pages.length; i += concurrency) {
    const batch = pages.slice(i, i + concurrency);
    const images = await Promise.all(
      batch.map(page => renderPage(page))
    );
    results.push(...images);
  }

  return results;
}

async function renderPage(page, scale = 2) {
  const viewport = page.getViewport({ scale });
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');

  canvas.width = viewport.width;
  canvas.height = viewport.height;

  await page.render({ canvasContext: ctx, viewport }).promise;
  return canvas.toDataURL('image/png');
}

# Fast API backend for Writola
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from anthropic import AsyncAnthropic
import asyncio

app = FastAPI(title="Writola API")
claude = AsyncAnthropic(api_key=settings.ANTHROPIC_API_KEY)

@app.post("/api/generate")
async def generate_article(request: GenerateRequest):
    """Generate article using Claude API with streaming."""

    async def stream_generator():
        """Stream Claude response in real-time."""
        try:
            async with claude.messages.stream(
                model="claude-3-5-sonnet-20241022",
                max_tokens=4096,
                messages=[{"role": "user", "content": request.prompt}],
                temperature=0.7,
            ) as stream:
                async for text in stream.text_stream:
                    # Server-Sent Events format
                    yield f"data: {json.dumps({'delta_text': text})}\n\n"

        except Exception as e:
            logger.error(f"Generation failed: {e}")
            yield f"data: {json.dumps({'error': str(e)})}\n\n"

    return StreamingResponse(
        stream_generator(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
        }
    )