Update app.py

app.py

@@ -1,51 +1,255 @@
-from fontTools.pens.recordingPen import RecordingPen
-from fontTools.svgLib.path import parsePath
-
-def parse_svg_path(path_data):
-    """ Parse SVG path data and return a sequence of drawing commands."""
-    path = parsePath(path_data)
-    pen = RecordingPen()
-    current_point = (0, 0)
-    for segment in path:
-        if segment.command == "M":
-            current_point = (segment.endPoint.real, segment.endPoint.imag)
-            pen.moveTo(current_point)
-        elif segment.command == "L":
-            current_point = (segment.endPoint.real, segment.endPoint.imag)
-            pen.lineTo(current_point)
-        elif segment.command == "C":
-            current_point = (segment.endPoint.real, segment.endPoint.imag)
-            pen.curveTo(
-                ((segment.ctrl1.real, segment.ctrl1.imag),
-                 (segment.ctrl2.real, segment.ctrl2.imag),
-                 current_point)
-            )
-        elif segment.command == "Z":
-            pen.closePath()
-    return pen.value
-
-def build_ufo_from_glyphs(glyphs):
+import spaces
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+import gradio as gr
+import torch
+from threading import Thread
+import re
+import io
+import zipfile
+import tempfile
+import os
+import glob
+
+# UFO / FONTMAKE
+from defcon import Font, Glyph
+from fontmake.font_project import FontProject
+from ufo2ft.util import _readSVG
+
+# ------------------------
+# MODELE
+# ------------------------
+def load_model():
+    tokenizer = AutoTokenizer.from_pretrained("ChevalierJoseph/typtop")
+    model = AutoModelForCausalLM.from_pretrained("ChevalierJoseph/typtop")
+    return tokenizer, model
+
+# ------------------------
+# SVG + GLYPH EXTRACTION
+# ------------------------
+def generate_svg(path_data, width=50, height=50):
+    svg_template = f"""
+    <svg width="{width}" height="{height}" viewBox="0 0 {width} {height}" xmlns="http://www.w3.org/2000/svg">
+      <path d="{path_data}" fill="black"/>
+    </svg>
+    """
+    return svg_template
+
+def extract_glyphs(text):
+    pattern = r"Glyph\s+([A-Z])\s+([MmZzLlHhVvCcSsQqTtAa0-9,\s\.\-]+?)(?=\s*Glyph\s+[A-Z]|\s*$)"
+    glyphs = re.findall(pattern, text)
+    return glyphs
+
+def generate_glyphs_html(glyphs, cols=5, width=100, height=100):
+    html_parts = []
+    for lettre, path in glyphs:
+        svg_content = f"""
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="-100 -800 900 900" width="{width}" height="{height}">
+          <g transform="translate(0, 0)">
+            <path d="{path.strip()}" fill="black"/>
+          </g>
+        </svg>
+        """
+        html_parts.append(f"<div style='display: inline-block; margin: 10px; text-align: center;'><h3>{lettre}</h3>{svg_content}</div>")
+    grid_style = f"display: grid; grid-template-columns: repeat({cols}, 1fr); gap: 20px;"
+    return f'<div style="{grid_style}">{"".join(html_parts)}</div>'
+
+def generate_svg_files(glyphs, width=100, height=100):
+    svg_files = {}
+    for lettre, path in glyphs:
+        svg_content = f"""
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="-100 -800 900 900" width="{width}" height="{height}">
+          <g transform="translate(0, 0)">
+            <path d="{path.strip()}" fill="black"/>
+          </g>
+        </svg>
+        """
+        svg_files[f"{lettre}.svg"] = svg_content
+    return svg_files
+
+def create_zip(svg_files):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp_file:
+        zip_path = tmp_file.name
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for filename, content in svg_files.items():
+            zip_file.writestr(filename, content)
+    return zip_path
+
+# ------------------------
+# UFO / FONTMAKE (copie exacte des SVG)
+# ------------------------
+def build_ufo_from_glyphs_svg_direct(glyphs):
     font = Font()
     font.info.familyName = "TipTopType"
     font.info.styleName = "Regular"
-    for letter, path_data in glyphs:
-        glyph = Glyph()
-        glyph.name = letter
-        glyph.unicode = ord(letter)
-        pen = glyph.getPen()
-        try:
-            commands = parse_svg_path(path_data.strip())
-            for cmd in commands:
-                if cmd[0] == "moveTo":
-                    pen.moveTo(cmd[1])
-                elif cmd[0] == "lineTo":
-                    pen.lineTo(cmd[1])
-                elif cmd[0] == "curveTo":
-                    pen.curveTo(cmd[1][0], cmd[1][1], cmd[1][2])
-                elif cmd[0] == "closePath":
-                    pen.closePath()
-            glyph.width = 600  # largeur du glyphe
-        except Exception as e:
-            print(f"Erreur injection SVG pour {letter}: {e}")
-        font.insertGlyph(glyph)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        for letter, path_data in glyphs:
+            # Crée un fichier SVG temporaire pour ce glyphe
+            svg_path = os.path.join(tmpdir, f"{letter}.svg")
+            with open(svg_path, "w") as f:
+                f.write(f'<svg xmlns="http://www.w3.org/2000/svg"><path d="{path_data.strip()}" /></svg>')
+
+            glyph = Glyph()
+            glyph.name = letter
+            glyph.unicode = ord(letter)
+
+            # Lit le SVG et ajoute les contours directement dans le glyphe
+            contours, _ = _readSVG(svg_path)
+            for contour in contours:
+                glyph.appendContour(contour)
+
+            font.insertGlyph(glyph)
+
     return font
+
+def save_otf_font(glyphs, font_name="TipTopType-Regular.otf"):
+    if not glyphs:
+        return None
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ufo_path = os.path.join(tmpdir, "font.ufo")
+        font = build_ufo_from_glyphs_svg_direct(glyphs)
+        font.save(ufo_path)
+
+        output_dir = os.path.join(tmpdir, "out")
+        os.makedirs(output_dir, exist_ok=True)
+
+        project = FontProject()
+        project.run_from_ufos([ufo_path], output=["otf"], output_dir=output_dir)
+
+        otf_files = glob.glob(os.path.join(output_dir, "**/*.otf"), recursive=True)
+        if not otf_files:
+            raise FileNotFoundError("Aucun fichier OTF généré par fontmake.")
+
+        generated_path = otf_files[0]
+        final_path = os.path.join(tempfile.gettempdir(), font_name)
+        os.replace(generated_path, final_path)
+
+        return final_path
+
+# ------------------------
+# GENERATION
+# ------------------------
+@spaces.GPU(duration=180)
+def respond(message: str, system_message: str, max_tokens: int, temperature: float, top_p: float):
+    tokenizer, model = load_model()
+    if torch.cuda.is_available():
+        model = model.to('cuda')
+    model_device = next(model.parameters()).device
+
+    messages = [{"role": "system", "content": system_message}]
+    messages.append({"role": "user", "content": message})
+
+    inputs = tokenizer.apply_chat_template(
+        messages,
+        tokenize=True,
+        add_generation_prompt=True,
+        return_tensors="pt",
+    ).to(model_device)
+
+    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+    generation_kwargs = {
+        "input_ids": inputs,
+        "streamer": streamer,
+        "max_new_tokens": max_tokens,
+        "temperature": float(temperature) if temperature > 0 else None,
+        "top_p": float(top_p) if top_p < 1.0 else None,
+        "do_sample": True,
+        "use_cache": True,
+    }
+    if temperature <= 0.01:
+        generation_kwargs["do_sample"] = False
+        generation_kwargs.pop("temperature", None)
+        generation_kwargs.pop("top_p", None)
+
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    partial_response = ""
+    for new_text in streamer:
+        partial_response += new_text
+        glyphs = extract_glyphs(partial_response)
+        yield partial_response, glyphs
+    thread.join()
+
+# ------------------------
+# GRADIO APP
+# ------------------------
+def create_demo():
+    with gr.Blocks() as demo:
+        gr.Markdown("# TypTopType")
+        glyphs_state = gr.State([])
+        message_history = gr.State([])
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                msg = gr.Textbox(label="input box, type here")
+                system_message = gr.Textbox(
+                    value="Based on the following text, give me the svgpath of the glyphs from A to Z.",
+                    visible=False
+                )
+                max_tokens = gr.Slider(minimum=1, maximum=9048, value=9048, step=1, visible=False)
+                temperature = gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, visible=False)
+                top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, visible=False)
+                cols = gr.Slider(minimum=1, maximum=10, value=5, step=1, visible=False)
+                width = gr.Slider(minimum=50, maximum=200, value=100, step=10, visible=False)
+                height = gr.Slider(minimum=50, maximum=200, value=100, step=10, visible=False)
+
+                download_btn = gr.Button("Download svg file")
+                download_otf_btn = gr.Button("Download OTF font")
+
+            with gr.Column(scale=3):
+                gr.Markdown("## preview")
+                svg_preview = gr.HTML(label="SVG Preview")
+                download_output = gr.File(label="Download ZIP")
+                download_otf_output = gr.File(label="Download OTF")
+
+        def user(user_message, history):
+            return "", history + [[user_message, None]]
+
+        def bot(history, system_message, max_tokens, temperature, top_p, cols, width, height):
+            message = history[-1][0]
+            response_generator = respond(message, system_message, max_tokens, temperature, top_p)
+            full_response, glyphs_list = "", []
+            for partial_response, glyphs in response_generator:
+                full_response = partial_response
+                if glyphs:
+                    glyphs_list = glyphs
+                svg_html = generate_glyphs_html(glyphs_list, cols=cols, width=width, height=height) if glyphs_list else "No glyphs found."
+                yield svg_html, glyphs_list
+
+        def download_svg(glyphs, width, height):
+            if not glyphs:
+                return None
+            svg_files = generate_svg_files(glyphs, width=width, height=height)
+            zip_path = create_zip(svg_files)
+            return zip_path
+
+        def download_otf(glyphs):
+            if not glyphs:
+                return None
+            return save_otf_font(glyphs)
+
+        msg.submit(user, [msg, message_history], [msg, message_history], queue=False).then(
+            bot, [message_history, system_message, max_tokens, temperature, top_p, cols, width, height], [svg_preview, glyphs_state]
+        )
+
+        download_btn.click(
+            download_svg,
+            inputs=[glyphs_state, width, height],
+            outputs=download_output
+        )
+
+        download_otf_btn.click(
+            download_otf,
+            inputs=[glyphs_state],
+            outputs=download_otf_output
+        )
+
+    return demo
+
+demo = create_demo()
+
+if __name__ == "__main__":
+    demo.launch()