Update app.py

app.py

@@ -1,274 +1,51 @@
-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
-
-# Fontmake / UFO
-from fontmake.font_project import FontProject
-from defcon import Font, Glyph
-from svgpathtools import parse_path, Line, CubicBezier, QuadraticBezier
-
-# ------------------------
-# 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
-# ------------------------
-def add_svg_to_glyph(glyph: Glyph, path_d: str, width=600):
-    pen = glyph.getPen()
-    try:
-        svg_path = parse_path(path_d)
-        for segment in svg_path:
-            start = segment.start
-            end = segment.end
-            if isinstance(segment, Line):
-                pen.moveTo((start.real, start.imag))
-                pen.lineTo((end.real, end.imag))
-                pen.closePath()
-            elif isinstance(segment, CubicBezier):
-                pen.moveTo((start.real, start.imag))
-                pen.curveTo(
-                    (segment.control1.real, segment.control1.imag),
-                    (segment.control2.real, segment.control2.imag),
-                    (end.real, end.imag)
-                )
-                pen.closePath()
-            elif isinstance(segment, QuadraticBezier):
-                pen.moveTo((start.real, start.imag))
-                pen.qCurveTo(
-                    (segment.control.real, segment.control.imag),
-                    (end.real, end.imag)
-                )
-                pen.closePath()
-    except Exception as e:
-        print(f"Erreur parsing SVG: {e}")
-    glyph.width = width
+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):
     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)
-        add_svg_to_glyph(glyph, path_data)
+        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)
-
     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(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()