Upload 4 files

README.md

@@ -1,28 +1,37 @@
 ---
-title: Word DOCX Paraphraser ZeroGPU
-emoji: 🦜
-colorFrom: blue
-colorTo: green
+title: CS Academic Paraphraser
+emoji: ✨
+colorFrom: indigo
+colorTo: pink
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
-pinned: false
+pinned: true
+short_description: Paraphrase .docx or pasted text, keep Word layout
 ---
 
-# Word DOCX Paraphraser — Gradio + ZeroGPU
+# CS Academic Paraphraser — by CS Software Solutions
 
-Native Gradio Hugging Face Space for uploading a `.docx`, paraphrasing eligible
-prose with `prithivida/parrot_paraphraser_on_T5`, injecting the revised wording
-back into the original DOCX structure, and downloading the result.
+Upload a `.docx` **or paste text**, paraphrase eligible prose with
+`prithivida/parrot_paraphraser_on_T5`, and download the result. For Word files the
+new wording is injected back into the original document, so sections, styles,
+tables, images, numbering and headers/footers stay in place.
+
+After each run the app shows **tentative indicators**:
+
+- **Similarity to source** — word n-gram overlap between output and your original
+- **AI indicator (input / output)** — stylometric heuristic (sentence-length variation, stock phrasing, uniformity)
+- **Vocabulary changed** — share of new wording
+
+These are local estimates, not Turnitin / iThenticate / AI-detector results.
 
 ## Hardware
 
-Select **ZeroGPU** in the Hugging Face Space hardware settings.
+Settings → Hardware → **ZeroGPU**.
 
 ## Files
 
 - `app.py`
 - `requirements.txt`
+- `logo.png` (brand logo shown in the header)
 - `README.md`
-
-No Dockerfile, Streamlit server, FastAPI server, or manual Uvicorn process is used.

app.py

@@ -1,5 +1,7 @@
+import base64
 import os
 import re
+import statistics
 import tempfile
 import threading
 from pathlib import Path
@@ -10,38 +12,205 @@ import torch
 from docx import Document
 from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
 
+# ---------------------------------------------------------------------------
+# Brand (colours sampled from the CS Software Solutions logo)
+# ---------------------------------------------------------------------------
+BRAND = {
+    "navy": "#07228B",
+    "purple": "#47148B",
+    "magenta": "#E92E7F",
+    "red": "#E12B41",
+    "orange": "#FE5828",
+    "yellow": "#F5C518",
+    "green": "#50BF49",
+    "sky": "#50B4EF",
+    "grey": "#4A4A4A",
+}
+RAINBOW = (
+    f"linear-gradient(90deg, {BRAND['purple']}, {BRAND['navy']}, {BRAND['sky']}, "
+    f"{BRAND['green']}, {BRAND['yellow']}, {BRAND['orange']}, {BRAND['red']}, {BRAND['magenta']})"
+)
+APP_NAME = "CS Academic Paraphraser"
+SITE_URL = "https://cssoftwaresolutions.in"
+
+LOGO_PATH = Path(__file__).parent / "logo.png"
+LOGO_SRC = ""
+if LOGO_PATH.exists():
+    LOGO_SRC = "data:image/png;base64," + base64.b64encode(LOGO_PATH.read_bytes()).decode()
+
+# ---------------------------------------------------------------------------
+# Model (kept in CPU RAM while idle; moved to GPU only inside @spaces.GPU)
+# ---------------------------------------------------------------------------
 MODEL_ID = os.getenv("PARROT_MODEL", "prithivida/parrot_paraphraser_on_T5")
-
-# Model stays in CPU RAM while the Space is idle.
 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
 model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_ID).eval()
 model_lock = threading.Lock()
 
+GPU_CHUNK = 64          # sentences per ZeroGPU allocation
+MAX_PASTE_WORDS = 6000  # keeps a single paste request within quota
+
 
+# ---------------------------------------------------------------------------
+# Text helpers
+# ---------------------------------------------------------------------------
 def split_sentences(text):
-    """Conservative sentence splitting for normal prose."""
-    parts = re.split(r"(?<=[.!?])\s+(?=[A-Z0-9])", text.strip())
+    parts = re.split(r"(?<=[.!?])\s+(?=[A-Z0-9\"'(\[])", text.strip())
     return [p.strip() for p in parts if p.strip()]
 
 
 def should_process(text, min_words):
     text = (text or "").strip()
-
     if len(text.split()) < int(min_words):
         return False
-
-    # Skip standalone URLs/emails.
     if re.fullmatch(r"https?://\S+|www\.\S+|\S+@\S+\.\S+", text):
         return False
-
-    # Skip lines dominated by numbers/symbols/equation-like content.
     alpha = sum(ch.isalpha() for ch in text)
     if alpha < max(5, int(len(text) * 0.35)):
         return False
-
     return True
 
 
+def words(text):
+    return re.findall(r"[A-Za-z0-9']+", (text or "").lower())
+
+
+# ---------------------------------------------------------------------------
+# Tentative indicators (local heuristics — NOT Turnitin / iThenticate / GPTZero)
+# ---------------------------------------------------------------------------
+def _ngrams(tokens, n):
+    return {tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)}
+
+
+def similarity_to_source(original, revised):
+    """Share of the revised text's word n-grams that also occur in the original."""
+    a, b = words(original), words(revised)
+    if len(b) < 4 or len(a) < 4:
+        return 0.0
+    scores, weights = [], []
+    for n, w in ((2, 0.2), (3, 0.35), (4, 0.45)):
+        gb = _ngrams(b, n)
+        if not gb:
+            continue
+        scores.append(len(gb & _ngrams(a, n)) / len(gb))
+        weights.append(w)
+    if not weights:
+        return 0.0
+    return 100.0 * sum(s * w for s, w in zip(scores, weights)) / sum(weights)
+
+
+AI_MARKERS = [
+    "delve", "delves", "delving", "furthermore", "moreover", "additionally",
+    "in conclusion", "it is important to note", "it is worth noting", "plays a crucial role",
+    "plays a pivotal role", "pivotal", "crucial", "comprehensive", "leverage", "leveraging",
+    "seamless", "seamlessly", "robust", "landscape", "underscore", "underscores",
+    "notably", "in today's", "fostering", "foster", "multifaceted", "intricate",
+    "realm", "tapestry", "navigate", "navigating", "holistic", "paramount",
+    "a testament to", "shed light", "sheds light", "ever-evolving", "cutting-edge",
+    "in the realm of", "overall,", "ultimately", "enhance", "enhancing", "streamline",
+    "valuable insights", "key role", "vital role", "significantly",
+]
+
+
+def ai_likelihood(text):
+    """Stylometric estimate (0–100) of machine-like writing."""
+    toks = words(text)
+    if len(toks) < 30:
+        return None
+    sents = split_sentences(text) or [text]
+    lengths = [len(words(s)) for s in sents if words(s)]
+
+    # 1. Burstiness: humans vary sentence length more than LLMs.
+    if len(lengths) >= 3:
+        cv = statistics.pstdev(lengths) / max(1.0, statistics.mean(lengths))
+        burst = min(1.0, max(0.0, (0.60 - cv) / 0.45))
+    else:
+        burst = 0.5
+
+    # 2. Density of stock "LLM" vocabulary per 100 words.
+    low = " " + " ".join(toks) + " "
+    raw = (text or "").lower()
+    hits = sum(raw.count(m) if " " in m or "," in m else low.count(f" {m} ") for m in AI_MARKERS)
+    marker = min(1.0, (hits / len(toks) * 100) / 2.5)
+
+    # 3. Uniformity: mid-length sentences, repeated openers, low lexical variety.
+    mean_len = statistics.mean(lengths)
+    band = 1.0 if 16 <= mean_len <= 28 else 0.4
+    openers = [words(s)[0] for s in sents if words(s)]
+    repeat = 1 - len(set(openers)) / len(openers) if openers else 0
+    window = toks[:400]
+    ttr = len(set(window)) / len(window)
+    variety = min(1.0, max(0.0, (0.62 - ttr) / 0.25))
+    uniform = 0.45 * band + 0.3 * min(1.0, repeat * 2) + 0.25 * variety
+
+    score = 100 * (0.40 * burst + 0.35 * marker + 0.25 * uniform)
+    return float(max(3.0, min(97.0, score)))
+
+
+def words_changed(original, revised):
+    a, b = words(original), words(revised)
+    if not b:
+        return 0.0
+    return 100.0 * (1 - len(set(b) & set(a)) / len(set(b)))
+
+
+def _level(value, invert=False):
+    if value is None:
+        return "#9aa0a6", "n/a"
+    v = 100 - value if invert else value
+    if v < 30:
+        return BRAND["green"], "Low"
+    if v < 55:
+        return BRAND["orange"], "Moderate"
+    return BRAND["red"], "High"
+
+
+def _gauge(title, value, caption, invert=False, fixed_color=None):
+    color, label = _level(value, invert)
+    if fixed_color:
+        color = fixed_color
+        label = "Rewrite depth"
+    pct = 0 if value is None else round(value)
+    shown = "—" if value is None else f"{pct}%"
+    return f"""
+    <div class="cs-gauge">
+      <div class="cs-ring" style="--p:{pct};--c:{color}">
+        <div class="cs-ring-inner"><span>{shown}</span></div>
+      </div>
+      <div class="cs-gauge-title">{title}</div>
+      <div class="cs-chip" style="background:{color}1f;color:{color}">{label}</div>
+      <div class="cs-gauge-cap">{caption}</div>
+    </div>"""
+
+
+def score_panel(original, revised):
+    sim = similarity_to_source(original, revised)
+    ai_in = ai_likelihood(original)
+    ai_out = ai_likelihood(revised)
+    changed = words_changed(original, revised)
+    return f"""
+    <div class="cs-scores">
+      {_gauge("Similarity to source", sim, "Word n-gram overlap with your original")}
+      {_gauge("AI indicator · input", ai_in, "Stylometric estimate of the original")}
+      {_gauge("AI indicator · output", ai_out, "Stylometric estimate after paraphrasing")}
+      {_gauge("Vocabulary changed", changed, "Share of new wording", fixed_color=BRAND["navy"])}
+    </div>
+    <div class="cs-disclaimer">
+      <b>Tentative indicators only.</b> Similarity is measured against your own original text,
+      not against internet or journal databases, and the AI indicator is a stylometric heuristic.
+      Results will differ from Turnitin, iThenticate or other detectors. Always review the
+      output for meaning, technical terms and citations before use.
+    </div>"""
+
+
+EMPTY_SCORES = """
+<div class="cs-scores cs-empty">
+  <div>Scores appear here after paraphrasing — similarity to source, AI indicators and rewrite depth.</div>
+</div>"""
+
+
+# ---------------------------------------------------------------------------
+# DOCX structure helpers
+# ---------------------------------------------------------------------------
 def iter_table_paragraphs(table):
     for row in table.rows:
         for cell in row.cells:
@@ -52,12 +221,6 @@ def iter_table_paragraphs(table):
 
 
 def collect_paragraphs(doc):
-    """
-    Yield unique paragraphs from:
-    - document body
-    - tables / nested tables
-    - headers / footers
-    """
     seen = set()
 
     def unique(paragraphs):
@@ -68,76 +231,48 @@ def collect_paragraphs(doc):
                 yield paragraph
 
     yield from unique(doc.paragraphs)
-
     for table in doc.tables:
         yield from unique(iter_table_paragraphs(table))
-
     for section in doc.sections:
-        parts = (
-            section.header,
-            section.footer,
-            section.first_page_header,
-            section.first_page_footer,
-            section.even_page_header,
-            section.even_page_footer,
-        )
-        for part in parts:
+        for part in (
+            section.header, section.footer,
+            section.first_page_header, section.first_page_footer,
+            section.even_page_header, section.even_page_footer,
+        ):
             yield from unique(part.paragraphs)
             for table in part.tables:
                 yield from unique(iter_table_paragraphs(table))
 
 
-def replace_text_preserving_paragraph(paragraph, new_text):
-    """
-    Replace ordinary textual runs without rebuilding the paragraph.
+def _is_protected(run):
+    return bool(
+        run._r.xpath(".//w:drawing")
+        or run._r.xpath(".//w:object")
+        or run._r.xpath(".//w:fldChar")
+    )
 
-    This retains paragraph properties, style, numbering, tables, drawings,
-    bookmarks and other non-text paragraph XML. The first usable text run
-    becomes the target, preserving that run's character formatting.
-    """
-    runs = list(paragraph.runs)
 
+def replace_text_preserving_paragraph(paragraph, new_text):
+    runs = list(paragraph.runs)
     if not runs:
         paragraph.add_run(new_text)
         return
-
-    target = None
-    for run in runs:
-        has_drawing = bool(run._r.xpath(".//w:drawing"))
-        has_object = bool(run._r.xpath(".//w:object"))
-        has_field = bool(run._r.xpath(".//w:fldChar"))
-        if not (has_drawing or has_object or has_field):
-            target = run
-            break
-
+    target = next((r for r in runs if not _is_protected(r)), None)
     if target is None:
         target = paragraph.add_run()
-
     target.text = new_text
-
     for run in runs:
-        if run is target:
-            continue
-
-        # Do not disturb drawings, embedded objects or field-code runs.
-        protected = (
-            bool(run._r.xpath(".//w:drawing"))
-            or bool(run._r.xpath(".//w:object"))
-            or bool(run._r.xpath(".//w:fldChar"))
-        )
-        if not protected:
+        if run is not target and not _is_protected(run):
             run.text = ""
 
 
+# ---------------------------------------------------------------------------
+# Paraphrasing
+# ---------------------------------------------------------------------------
 @spaces.GPU(duration=120)
 def paraphrase_batch(texts, temperature):
-    """
-    One ZeroGPU allocation processes a list of paragraph/sentence strings.
-    This is much more efficient than requesting a GPU separately per sentence.
-    """
     if not texts:
         return []
-
     if not torch.cuda.is_available():
         raise RuntimeError("ZeroGPU allocation did not expose CUDA. Please try again.")
 
@@ -147,21 +282,15 @@ def paraphrase_batch(texts, temperature):
 
     with model_lock:
         model.to(device)
-
         try:
             with torch.inference_mode():
                 for start in range(0, len(texts), 8):
                     chunk = texts[start:start + 8]
-
                     encoded = tokenizer(
-                        ["paraphrase: " + text for text in chunk],
-                        return_tensors="pt",
-                        padding=True,
-                        truncation=True,
-                        max_length=256,
+                        ["paraphrase: " + t for t in chunk],
+                        return_tensors="pt", padding=True, truncation=True, max_length=256,
                     )
                     encoded = {k: v.to(device) for k, v in encoded.items()}
-
                     generated = model.generate(
                         **encoded,
                         do_sample=True,
@@ -171,69 +300,59 @@ def paraphrase_batch(texts, temperature):
                         max_new_tokens=180,
                         no_repeat_ngram_size=3,
                     )
-
-                    decoded = tokenizer.batch_decode(
-                        generated.detach().cpu(),
-                        skip_special_tokens=True,
-                    )
-
+                    decoded = tokenizer.batch_decode(generated.detach().cpu(), skip_special_tokens=True)
                     outputs.extend(
-                        [
-                            candidate.strip() if candidate.strip() else source
-                            for source, candidate in zip(chunk, decoded)
-                        ]
+                        c.strip() if c.strip() else s for s, c in zip(chunk, decoded)
                     )
-
                     del encoded, generated
-
         finally:
             model.to("cpu")
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
-
     return outputs
 
 
-def paraphrase_paragraphs(texts, temperature):
-    """
-    Preserve sentence order within each paragraph while allowing batch GPU inference.
-    """
-    sentence_groups = []
-    flat_sentences = []
-
+def paraphrase_paragraphs(texts, temperature, progress=None, lo=0.15, hi=0.85):
+    groups, flat = [], []
     for text in texts:
-        sentences = split_sentences(text)
-        if not sentences:
-            sentences = [text]
-
-        start = len(flat_sentences)
-        flat_sentences.extend(sentences)
-        sentence_groups.append((start, len(flat_sentences)))
-
-    rewritten_sentences = paraphrase_batch(flat_sentences, temperature)
-
-    rewritten_paragraphs = []
-    for start, end in sentence_groups:
-        rewritten_paragraphs.append(" ".join(rewritten_sentences[start:end]))
-
-    return rewritten_paragraphs
+        sents = split_sentences(text) or [text]
+        start = len(flat)
+        flat.extend(sents)
+        groups.append((start, len(flat)))
+
+    rewritten = []
+    total = max(1, len(flat))
+    for i in range(0, len(flat), GPU_CHUNK):
+        if progress is not None:
+            progress(lo + (hi - lo) * i / total, desc=f"Paraphrasing sentences {i + 1}–{min(i + GPU_CHUNK, total)} of {total}")
+        rewritten.extend(paraphrase_batch(flat[i:i + GPU_CHUNK], temperature))
+
+    return [" ".join(rewritten[s:e]) for s, e in groups]
+
+
+def _preview(pairs, limit=10):
+    blocks = []
+    for i, (before, after) in enumerate(pairs[:limit], 1):
+        blocks.append(
+            f"#### Change {i}\n**Original:** {before}\n\n**Paraphrased:** {after}"
+        )
+    return "\n\n---\n\n".join(blocks) if blocks else "No textual changes were generated."
 
 
+# ---------------------------------------------------------------------------
+# Handlers
+# ---------------------------------------------------------------------------
 def process_docx(file_path, temperature, min_words, progress=gr.Progress()):
     if not file_path:
         raise gr.Error("Please upload a .docx file.")
-
     source_path = Path(file_path)
     if source_path.suffix.lower() != ".docx":
         raise gr.Error("Only .docx Word documents are supported.")
 
     progress(0.05, desc="Opening Word document")
-
     doc = Document(str(source_path))
 
-    targets = []
-    originals = []
-
+    targets, originals = [], []
     for paragraph in collect_paragraphs(doc):
         text = paragraph.text
         if should_process(text, min_words):
@@ -243,116 +362,245 @@ def process_docx(file_path, temperature, min_words, progress=gr.Progress()):
     if not originals:
         raise gr.Error("No eligible prose paragraphs were found in the document.")
 
-    progress(0.15, desc=f"Paraphrasing {len(originals)} eligible paragraphs")
-
-    revised = paraphrase_paragraphs(originals, temperature)
-
-    progress(0.85, desc="Injecting revised text into original structure")
-
-    changed = 0
-    preview_lines = []
+    revised = paraphrase_paragraphs(originals, temperature, progress)
 
+    progress(0.9, desc="Injecting revised text into the original layout")
+    changed, pairs, final_after = 0, [], []
     for paragraph, before, after in zip(targets, originals, revised):
-        if after and after.strip() and after.strip() != before.strip():
-            replace_text_preserving_paragraph(paragraph, after.strip())
+        after = (after or "").strip()
+        if after and after != before.strip():
+            replace_text_preserving_paragraph(paragraph, after)
             changed += 1
+            pairs.append((before, after))
+            final_after.append(after)
+        else:
+            final_after.append(before)
 
-            if len(preview_lines) < 10:
-                preview_lines.append(
-                    f"### Change {len(preview_lines) + 1}\n"
-                    f"**Original:** {before}\n\n"
-                    f"**Paraphrased:** {after.strip()}"
-                )
-
-    fd, output_path = tempfile.mkstemp(
-        prefix=f"{source_path.stem}_paraphrased_",
-        suffix=".docx",
-    )
+    fd, output_path = tempfile.mkstemp(prefix=f"{source_path.stem}_paraphrased_", suffix=".docx")
     os.close(fd)
     doc.save(output_path)
-
     progress(1.0, desc="Completed")
 
     summary = (
-        f"Completed successfully.\n\n"
-        f"- Eligible paragraphs: **{len(originals)}**\n"
-        f"- Updated paragraphs: **{changed}**\n"
-        f"- Output structure: edited in the original DOCX rather than rebuilt."
+        f"✅ **Completed** — {changed} of {len(originals)} eligible paragraphs rewritten. "
+        f"Layout, styles, tables, images and headers/footers were kept in place."
     )
+    scores = score_panel("\n".join(originals), "\n".join(final_after))
+    return output_path, summary, scores, _preview(pairs)
 
-    preview = "\n\n---\n\n".join(preview_lines)
-    if not preview:
-        preview = "No textual changes were generated."
 
-    return output_path, summary, preview
+def process_text(text, temperature, min_words, progress=gr.Progress()):
+    text = (text or "").strip()
+    if not text:
+        raise gr.Error("Please paste some text to paraphrase.")
+    n_words = len(text.split())
+    if n_words > MAX_PASTE_WORDS:
+        raise gr.Error(
+            f"Pasted text has {n_words} words. Please keep it under {MAX_PASTE_WORDS} words, "
+            "or upload it as a .docx instead."
+        )
 
+    progress(0.05, desc="Reading pasted text")
+    paragraphs = [p.strip() for p in re.split(r"\n\s*\n|\r?\n", text)]
+    idx = [i for i, p in enumerate(paragraphs) if should_process(p, min_words)]
+    if not idx:
+        raise gr.Error(f"No paragraph has at least {int(min_words)} words of prose. Lower the minimum and try again.")
+
+    revised = paraphrase_paragraphs([paragraphs[i] for i in idx], temperature, progress)
+    result = list(paragraphs)
+    pairs = []
+    for i, after in zip(idx, revised):
+        after = (after or "").strip()
+        if after and after != paragraphs[i]:
+            result[i] = after
+            pairs.append((paragraphs[i], after))
+
+    output_text = "\n\n".join(p for p in result if p)
+
+    progress(0.95, desc="Preparing download")
+    doc = Document()
+    for p in result:
+        if p:
+            doc.add_paragraph(p)
+    fd, output_path = tempfile.mkstemp(prefix="paraphrased_text_", suffix=".docx")
+    os.close(fd)
+    doc.save(output_path)
+    progress(1.0, desc="Completed")
 
-with gr.Blocks(title="Word DOCX Paraphraser — ZeroGPU") as demo:
-    gr.Markdown(
-        """
-# 🦜 Word DOCX Paraphraser
-### Gradio + Hugging Face ZeroGPU
+    summary = f"✅ **Completed** — {len(pairs)} of {len(idx)} eligible paragraphs rewritten ({n_words} words in)."
+    scores = score_panel(
+        "\n".join(paragraphs[i] for i in idx),
+        "\n".join(result[i] for i in idx),
+    )
+    return output_text, output_path, summary, scores
+
+
+def count_words(text):
+    n = len((text or "").split())
+    color = BRAND["red"] if n > MAX_PASTE_WORDS else BRAND["grey"]
+    return f"<div class='cs-count' style='color:{color}'>{n:,} / {MAX_PASTE_WORDS:,} words</div>"
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+CSS = f"""
+:root {{
+  --cs-navy:{BRAND['navy']}; --cs-purple:{BRAND['purple']}; --cs-magenta:{BRAND['magenta']};
+  --cs-sky:{BRAND['sky']}; --cs-rainbow:{RAINBOW};
+}}
+.gradio-container {{ max-width: 1180px !important; margin: 0 auto !important;
+  font-family: 'Poppins', ui-sans-serif, system-ui, sans-serif !important; }}
+body, .gradio-container {{ background: #f6f7fb !important; }}
+
+.cs-header {{ display:flex; align-items:center; gap:22px; padding:22px 26px; border-radius:20px;
+  background:#fff; box-shadow:0 8px 30px rgba(7,34,139,.08); position:relative; overflow:hidden; }}
+.cs-header::after {{ content:""; position:absolute; left:0; right:0; bottom:0; height:5px; background:var(--cs-rainbow); }}
+.cs-header img {{ width:92px; height:92px; border-radius:50%; flex:none;
+  box-shadow:0 4px 14px rgba(0,0,0,.12); }}
+.cs-header h1 {{ margin:0; font-size:30px; font-weight:800; color:var(--cs-navy); letter-spacing:-.3px; line-height:1.15; }}
+.cs-header h1 span {{ color:var(--cs-magenta) !important; }}
+.cs-header p {{ margin:6px 0 0; color:#555; font-size:14.5px; }}
+.cs-tag {{ margin-top:8px; font-size:11.5px; letter-spacing:3px; color:#444; font-weight:600; }}
+.cs-tag b {{ color:var(--cs-magenta); }} .cs-tag i {{ color:var(--cs-navy); font-style:normal; }}
+@media (max-width:640px) {{ .cs-header {{ flex-direction:column; text-align:center; }} .cs-header h1 {{ font-size:24px; }} }}
+
+.cs-card {{ background:#fff !important; border-radius:18px !important; padding:18px !important;
+  box-shadow:0 6px 24px rgba(7,34,139,.06) !important; border:1px solid #eceef6 !important; }}
+
+button.primary, .cs-go {{ background:linear-gradient(90deg,var(--cs-navy),var(--cs-purple) 60%,var(--cs-magenta)) !important;
+  color:#fff !important; border:none !important; font-weight:700 !important; font-size:16px !important;
+  border-radius:12px !important; box-shadow:0 6px 18px rgba(71,20,139,.28) !important; }}
+button.primary:hover {{ filter:brightness(1.08); transform:translateY(-1px); }}
+
+.tabs button[role="tab"] {{ font-weight:600 !important; font-size:15px !important; }}
+.tabs button[role="tab"].selected {{ color:var(--cs-navy) !important; border-color:var(--cs-magenta) !important; }}
+
+.cs-scores {{ display:grid; grid-template-columns:repeat(4,1fr); gap:14px; }}
+@media (max-width:820px) {{ .cs-scores {{ grid-template-columns:repeat(2,1fr); }} }}
+.cs-scores.cs-empty {{ display:block; text-align:center; color:#888; padding:26px; border:2px dashed #e3e6f2; border-radius:16px; }}
+.cs-gauge {{ background:#fff; border:1px solid #eceef6; border-radius:16px; padding:16px 10px; text-align:center;
+  box-shadow:0 4px 16px rgba(7,34,139,.05); }}
+.cs-ring {{ width:104px; height:104px; margin:0 auto 10px; border-radius:50%;
+  background:conic-gradient(var(--c) calc(var(--p)*1%), #edf0f7 0); display:grid; place-items:center; }}
+.cs-ring-inner {{ width:80px; height:80px; border-radius:50%; background:#fff; display:grid; place-items:center; }}
+.cs-ring-inner span {{ font-size:22px; font-weight:800; color:#222; }}
+.cs-gauge-title {{ font-weight:700; color:var(--cs-navy); font-size:14px; }}
+.cs-chip {{ display:inline-block; margin:6px 0; padding:2px 12px; border-radius:99px; font-size:12px; font-weight:700; }}
+.cs-gauge-cap {{ font-size:11.5px; color:#777; line-height:1.35; }}
+.cs-disclaimer {{ margin-top:12px; font-size:12px; color:#666; background:#fff8ec; border-left:4px solid {BRAND['orange']};
+  padding:10px 14px; border-radius:10px; }}
+.cs-count {{ text-align:right; font-size:12px; margin-top:-6px; }}
+
+.cs-footer {{ text-align:center; margin-top:18px; padding:16px; color:#666; font-size:13px; }}
+.cs-footer .bar {{ height:3px; width:220px; margin:0 auto 12px; border-radius:3px; background:var(--cs-rainbow); }}
+.cs-footer a {{ color:var(--cs-navy); font-weight:700; text-decoration:none; }}
+footer {{ display:none !important; }}
+"""
 
-Upload an existing **`.docx` Word document**. The app paraphrases eligible prose
-and injects the revised text back into the original Word document instead of
-creating a new layout from scratch.
+FORCE_LIGHT = """
+() => {
+  const url = new URL(window.location);
+  if (url.searchParams.get('__theme') !== 'light') {
+    url.searchParams.set('__theme', 'light');
+    window.location.href = url.href;
+  }
+}
+"""
 
-**Designed to retain:** sections, margins/page setup, paragraph positions and
-styles, tables, images, headers/footers, numbering and other document objects.
+logo_html = f'<img src="{LOGO_SRC}" alt="CS Software Solutions logo">' if LOGO_SRC else ""
+HEADER = f"""
+<div class="cs-header">
+  {logo_html}
+  <div>
+    <h1>{APP_NAME.replace("Paraphraser", "<span>Paraphraser</span>")}</h1>
+    <p>Rewrite academic prose while keeping your Word layout intact — upload a <b>.docx</b> or paste text,
+       then review tentative similarity and AI-style indicators.</p>
+    <div class="cs-tag">INNOVATE <b>•</b> DEVELOP <i>•</i> DELIVER</div>
+  </div>
+</div>
+"""
 
-> **Formatting note:** when a rewritten paragraph contains several differently
-> formatted text runs, the new wording uses the first suitable run's character
-> formatting. This avoids rebuilding the document, but word-by-word mixed
-> bold/italic formatting cannot always be mapped exactly after the wording changes.
+FOOTER = f"""
+<div class="cs-footer">
+  <div class="bar"></div>
+  © CS Software Solutions · Tri-Crest Press &nbsp;|&nbsp; <a href="{SITE_URL}" target="_blank">cssoftwaresolutions.in</a><br>
+  Paraphrased output should be checked for accuracy and properly cited before submission.
+</div>
 """
-    )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_file = gr.File(
-                label="Upload Word document (.docx)",
-                file_types=[".docx"],
-                type="filepath",
-            )
-
-            temperature = gr.Slider(
-                minimum=0.3,
-                maximum=1.5,
-                value=0.9,
-                step=0.1,
-                label="Paraphrase variation",
-            )
-
-            min_words = gr.Slider(
-                minimum=5,
-                maximum=30,
-                value=8,
-                step=1,
-                label="Minimum words per paragraph",
-            )
-
-            run_button = gr.Button(
-                "Paraphrase and inject into DOCX",
-                variant="primary",
-            )
-
-        with gr.Column(scale=1):
-            status = gr.Markdown()
-            output_file = gr.File(
-                label="Download paraphrased Word document",
-                interactive=False,
-            )
-
-    preview = gr.Markdown(label="Preview")
-
-    run_button.click(
-        fn=process_docx,
-        inputs=[input_file, temperature, min_words],
-        outputs=[output_file, status, preview],
+theme = gr.themes.Soft(
+    primary_hue="indigo",
+    secondary_hue="pink",
+    neutral_hue="slate",
+    font=[gr.themes.GoogleFont("Poppins"), "ui-sans-serif", "sans-serif"],
+    radius_size="lg",
+)
+
+with gr.Blocks(title=f"{APP_NAME} · CS Software Solutions", theme=theme, css=CSS, js=FORCE_LIGHT) as demo:
+    gr.HTML(HEADER)
+
+    with gr.Tabs():
+        # ---------------- Upload DOCX ----------------
+        with gr.Tab("📄 Upload Word (.docx)"):
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=5, elem_classes="cs-card"):
+                    input_file = gr.File(label="Word document (.docx)", file_types=[".docx"], type="filepath")
+                    with gr.Accordion("Settings", open=False):
+                        d_temp = gr.Slider(0.3, 1.5, value=0.9, step=0.1, label="Paraphrase variation",
+                                           info="Higher = bolder rewording, lower = closer to the original")
+                        d_min = gr.Slider(5, 30, value=8, step=1, label="Minimum words per paragraph",
+                                          info="Shorter lines (headings, captions) are left untouched")
+                    d_btn = gr.Button("✨ Paraphrase document", variant="primary", size="lg")
+                    gr.Markdown(
+                        "<small>Keeps sections, margins, styles, tables, images, numbering and headers/footers. "
+                        "Mixed bold/italic inside one paragraph takes the first run's formatting.</small>"
+                    )
+                with gr.Column(scale=5, elem_classes="cs-card"):
+                    d_status = gr.Markdown("Upload a document and press **Paraphrase document**.")
+                    d_out = gr.File(label="Download paraphrased .docx", interactive=False)
+            d_scores = gr.HTML(EMPTY_SCORES)
+            with gr.Accordion("Preview of changes (first 10)", open=False):
+                d_preview = gr.Markdown()
+
+        # ---------------- Paste text ----------------
+        with gr.Tab("✍️ Paste text"):
+            with gr.Row(equal_height=True):
+                with gr.Column(scale=1, elem_classes="cs-card"):
+                    p_in = gr.Textbox(label="Your text", lines=16, max_lines=30,
+                                      placeholder="Paste your paragraphs here. Separate paragraphs with a blank line.")
+                    p_count = gr.HTML(count_words(""))
+                with gr.Column(scale=1, elem_classes="cs-card"):
+                    p_out = gr.Textbox(label="Paraphrased text", lines=16, max_lines=30,
+                                       show_copy_button=True, interactive=False)
+            with gr.Row():
+                with gr.Column(scale=5):
+                    with gr.Accordion("Settings", open=False):
+                        p_temp = gr.Slider(0.3, 1.5, value=0.9, step=0.1, label="Paraphrase variation")
+                        p_min = gr.Slider(3, 30, value=6, step=1, label="Minimum words per paragraph")
+                    p_btn = gr.Button("✨ Paraphrase text", variant="primary", size="lg")
+                with gr.Column(scale=5):
+                    p_status = gr.Markdown()
+                    p_file = gr.File(label="Download as .docx", interactive=False)
+            p_scores = gr.HTML(EMPTY_SCORES)
+
+    gr.HTML(FOOTER)
+
+    d_btn.click(
+        process_docx,
+        inputs=[input_file, d_temp, d_min],
+        outputs=[d_out, d_status, d_scores, d_preview],
         api_name="paraphrase_docx",
     )
+    p_in.change(count_words, inputs=p_in, outputs=p_count, show_progress="hidden", queue=False)
+    p_btn.click(
+        process_text,
+        inputs=[p_in, p_temp, p_min],
+        outputs=[p_out, p_file, p_status, p_scores],
+        api_name="paraphrase_text",
+    )
+
+demo.queue(default_concurrency_limit=2, max_size=30)
 
-# Native Gradio Space entry point.
-# Do not add FastAPI, uvicorn.run(), or manual port binding.
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,3 +1,4 @@
+torch
 transformers>=4.45,<5
 sentencepiece>=0.2
 protobuf==3.20.3