All in global context

app.py

@@ -15,154 +15,153 @@ import time
 MODEL_PATH = "THUDM/GLM-4.1V-9B-Thinking"
 stop_generation = False
 
-processor = None
-model = None
-
-def load_model():
-    """加载模型和处理器"""
-    global processor, model
-    processor = AutoProcessor.from_pretrained(MODEL_PATH, use_fast=True)
-    model = Glm4vForConditionalGeneration.from_pretrained(
-        MODEL_PATH,
-        torch_dtype=torch.bfloat16,
-        device_map="auto",
-        attn_implementation="sdpa",
+# Global model and processor
+processor = AutoProcessor.from_pretrained(MODEL_PATH, use_fast=True)
+model = Glm4vForConditionalGeneration.from_pretrained(
+    MODEL_PATH,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    attn_implementation="sdpa",
+)
+
+
+def _strip_html(t):
+    return re.sub(r"<[^>]+>", "", t).strip()
+
+
+def _wrap_text(t):
+    return [{"type": "text", "text": t}]
+
+
+def _pdf_to_imgs(pdf_path):
+    doc = fitz.open(pdf_path)
+    imgs = []
+    for i in range(doc.page_count):
+        pix = doc.load_page(i).get_pixmap(dpi=180)
+        img_p = os.path.join(tempfile.gettempdir(), f"{Path(pdf_path).stem}_{i}.png")
+        pix.save(img_p)
+        imgs.append(img_p)
+    doc.close()
+    return imgs
+
+
+def _ppt_to_imgs(ppt_path):
+    tmp = tempfile.mkdtemp()
+    subprocess.run(
+        ["libreoffice", "--headless", "--convert-to", "pdf", "--outdir", tmp, ppt_path],
+        check=True,
     )
+    pdf_path = os.path.join(tmp, Path(ppt_path).stem + ".pdf")
+    return _pdf_to_imgs(pdf_path)
 
-class GLM4VModel:
-    def __init__(self):
-        pass
-
-    def _strip_html(self, t):
-        return re.sub(r"<[^>]+>", "", t).strip()
-
-    def _wrap_text(self, t):
-        return [{"type": "text", "text": t}]
-
-    def _pdf_to_imgs(self, pdf_path):
-        doc = fitz.open(pdf_path)
-        imgs = []
-        for i in range(doc.page_count):
-            pix = doc.load_page(i).get_pixmap(dpi=180)
-            img_p = os.path.join(tempfile.gettempdir(), f"{Path(pdf_path).stem}_{i}.png")
-            pix.save(img_p)
-            imgs.append(img_p)
-        doc.close()
-        return imgs
-
-    def _ppt_to_imgs(self, ppt_path):
-        tmp = tempfile.mkdtemp()
-        subprocess.run(
-            ["libreoffice", "--headless", "--convert-to", "pdf", "--outdir", tmp, ppt_path],
-            check=True,
-        )
-        pdf_path = os.path.join(tmp, Path(ppt_path).stem + ".pdf")
-        return self._pdf_to_imgs(pdf_path)
-
-    def _files_to_content(self, media):
-        out = []
-        for f in media or []:
-            ext = Path(f.name).suffix.lower()
-            if ext in [".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm", ".mpeg", ".m4v"]:
-                out.append({"type": "video", "url": f.name})
-            elif ext in [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".webp"]:
-                out.append({"type": "image", "url": f.name})
-            elif ext in [".ppt", ".pptx"]:
-                for p in self._ppt_to_imgs(f.name):
-                    out.append({"type": "image", "url": p})
-            elif ext == ".pdf":
-                for p in self._pdf_to_imgs(f.name):
-                    out.append({"type": "image", "url": p})
-        return out
-
-    def _stream_fragment(self, buf: str) -> str:
-        think_html = ""
-        if "<think>" in buf:
-            if "</think>" in buf:
-                seg = re.search(r"<think>(.*?)</think>", buf, re.DOTALL)
-                if seg:
-                    think_html = (
-                        "<details open><summary style='cursor:pointer;font-weight:bold;color:#bbbbbb;'>💭 Thinking</summary>"
-                        "<div style='color:#cccccc;line-height:1.4;padding:10px;border-left:3px solid #666;margin:5px 0;background-color:rgba(128,128,128,0.1);'>"
-                        + seg.group(1).strip().replace("\n", "<br>")
-                        + "</div></details>"
-                    )
-            else:
-                part = buf.split("<think>", 1)[1]
+
+def _files_to_content(media):
+    out = []
+    for f in media or []:
+        ext = Path(f.name).suffix.lower()
+        if ext in [".mp4", ".avi", ".mkv", ".mov", ".wmv", ".flv", ".webm", ".mpeg", ".m4v"]:
+            out.append({"type": "video", "url": f.name})
+        elif ext in [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".webp"]:
+            out.append({"type": "image", "url": f.name})
+        elif ext in [".ppt", ".pptx"]:
+            for p in _ppt_to_imgs(f.name):
+                out.append({"type": "image", "url": p})
+        elif ext == ".pdf":
+            for p in _pdf_to_imgs(f.name):
+                out.append({"type": "image", "url": p})
+    return out
+
+
+def _stream_fragment(buf: str) -> str:
+    think_html = ""
+    if "<think>" in buf:
+        if "</think>" in buf:
+            seg = re.search(r"<think>(.*?)</think>", buf, re.DOTALL)
+            if seg:
                 think_html = (
                     "<details open><summary style='cursor:pointer;font-weight:bold;color:#bbbbbb;'>💭 Thinking</summary>"
                     "<div style='color:#cccccc;line-height:1.4;padding:10px;border-left:3px solid #666;margin:5px 0;background-color:rgba(128,128,128,0.1);'>"
-                    + part.replace("\n", "<br>")
+                    + seg.group(1).strip().replace("\n", "<br>")
                     + "</div></details>"
                 )
+        else:
+            part = buf.split("<think>", 1)[1]
+            think_html = (
+                "<details open><summary style='cursor:pointer;font-weight:bold;color:#bbbbbb;'>💭 Thinking</summary>"
+                "<div style='color:#cccccc;line-height:1.4;padding:10px;border-left:3px solid #666;margin:5px 0;background-color:rgba(128,128,128,0.1);'>"
+                + part.replace("\n", "<br>")
+                + "</div></details>"
+            )
 
-        answer_html = ""
-        if "<answer>" in buf:
-            if "</answer>" in buf:
-                seg = re.search(r"<answer>(.*?)</answer>", buf, re.DOTALL)
-                if seg:
-                    answer_html = seg.group(1).strip()
-            else:
-                answer_html = buf.split("<answer>", 1)[1]
+    answer_html = ""
+    if "<answer>" in buf:
+        if "</answer>" in buf:
+            seg = re.search(r"<answer>(.*?)</answer>", buf, re.DOTALL)
+            if seg:
+                answer_html = seg.group(1).strip()
+        else:
+            answer_html = buf.split("<answer>", 1)[1]
 
-        if not think_html and not answer_html:
-            return self._strip_html(buf)
-        return think_html + answer_html
+    if not think_html and not answer_html:
+        return _strip_html(buf)
+    return think_html + answer_html
 
-    def _build_messages(self, raw_hist, sys_prompt):
-        msgs = []
 
-        if sys_prompt.strip():
-            msgs.append({"role": "system", "content": [{"type": "text", "text": sys_prompt.strip()}]})
+def _build_messages(raw_hist, sys_prompt):
+    msgs = []
 
-        for h in raw_hist:
-            if h["role"] == "user":
-                msgs.append({"role": "user", "content": h["content"]})
-            else:
-                raw = h["content"]
-                raw = re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL)
-                raw = re.sub(r"<details.*?</details>", "", raw, flags=re.DOTALL)
-                clean = self._strip_html(raw).strip()
-                msgs.append({"role": "assistant", "content": self._wrap_text(clean)})
-        return msgs
-
-    @spaces.GPU(duration=240)
-    def stream_generate(self, raw_hist, sys_prompt):
-        global stop_generation, processor, model
-        stop_generation = False
-        msgs = self._build_messages(raw_hist, sys_prompt)
-        inputs = processor.apply_chat_template(
-            msgs,
-            tokenize=True,
-            add_generation_prompt=True,
-            return_dict=True,
-            return_tensors="pt",
-            padding=True,
-        ).to(model.device)
-
-        streamer = TextIteratorStreamer(processor.tokenizer, skip_prompt=True, skip_special_tokens=False)
-        gen_args = dict(
-            inputs,
-            max_new_tokens=8192,
-            repetition_penalty=1.1,
-            do_sample=True,
-            top_k=2,
-            temperature=None,
-            top_p=1e-5,
-            streamer=streamer,
-        )
-
-        generation_thread = threading.Thread(target=model.generate, kwargs=gen_args)
-        generation_thread.start()
-
-        buf = ""
-        for tok in streamer:
-            if stop_generation:
-                break
-            buf += tok
-            yield self._stream_fragment(buf)
-
-        generation_thread.join()
+    if sys_prompt.strip():
+        msgs.append({"role": "system", "content": [{"type": "text", "text": sys_prompt.strip()}]})
+
+    for h in raw_hist:
+        if h["role"] == "user":
+            msgs.append({"role": "user", "content": h["content"]})
+        else:
+            raw = h["content"]
+            raw = re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL)
+            raw = re.sub(r"<details.*?</details>", "", raw, flags=re.DOTALL)
+            clean = _strip_html(raw).strip()
+            msgs.append({"role": "assistant", "content": _wrap_text(clean)})
+    return msgs
+
+
+@spaces.GPU(duration=240)
+def stream_generate(raw_hist, sys_prompt):
+    global stop_generation
+    stop_generation = False
+    msgs = _build_messages(raw_hist, sys_prompt)
+    inputs = processor.apply_chat_template(
+        msgs,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_dict=True,
+        return_tensors="pt",
+        padding=True,
+    ).to(model.device)
+
+    streamer = TextIteratorStreamer(processor.tokenizer, skip_prompt=True, skip_special_tokens=False)
+    gen_args = dict(
+        inputs,
+        max_new_tokens=8192,
+        repetition_penalty=1.1,
+        do_sample=True,
+        top_k=2,
+        temperature=None,
+        top_p=1e-5,
+        streamer=streamer,
+    )
+
+    generation_thread = threading.Thread(target=model.generate, kwargs=gen_args)
+    generation_thread.start()
+
+    buf = ""
+    for tok in streamer:
+        if stop_generation:
+            break
+        buf += tok
+        yield _stream_fragment(buf)
+
+    generation_thread.join()
 
 
 def format_display_content(content):
@@ -193,11 +192,6 @@ def create_display_history(raw_hist):
     return display_hist
 
 
-# 加载模型和处理器
-load_model()
-glm4v = GLM4VModel()
-
-
 def check_files(files):
     vids = imgs = ppts = pdfs = 0
     for f in files or []:
@@ -230,10 +224,10 @@ def chat(files, msg, raw_hist, sys_prompt):
         yield display_hist, copy.deepcopy(raw_hist), None, ""
         return
 
-    payload = glm4v._files_to_content(files) if files else None
+    payload = _files_to_content(files) if files else None
     if msg.strip():
         if payload is None:
-            payload = glm4v._wrap_text(msg.strip())
+            payload = _wrap_text(msg.strip())
         else:
             payload.append({"type": "text", "text": msg.strip()})
 
@@ -248,7 +242,7 @@ def chat(files, msg, raw_hist, sys_prompt):
     display_hist = create_display_history(raw_hist)
     yield display_hist, copy.deepcopy(raw_hist), None, ""
 
-    for chunk in glm4v.stream_generate(raw_hist[:-1], sys_prompt):
+    for chunk in stream_generate(raw_hist[:-1], sys_prompt):
         if stop_generation:
             break
         place["content"] = chunk