Update app.py

app.py

@@ -1,18 +1,19 @@
-import re
-import os
-import tempfile
-import glob
-from fontTools.pens.svgPathPen import SVGPathPen
-from fontTools.svgLib.path import parsePath
-from defcon import Font, Glyph
-from fontmake.font_project import FontProject
 import spaces
 from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
 import gradio as gr
 import torch
 from threading import Thread
-import zipfile
+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
@@ -76,59 +77,73 @@ def create_zip(svg_files):
 # ------------------------
 # UFO / FONTMAKE
 # ------------------------
-def parse_svg_path(path_data, glyph):
-    """ Parse the SVG path and draw it into the glyph using the correct pen methods."""
+def add_svg_to_glyph(glyph: Glyph, path_d: str, width=600):
     pen = glyph.getPen()
-    path = parsePath(path_data)
-
-    for segment in path:
-        if segment.length() > 0:
-            if segment.command == "M":
-                pen.moveTo((segment.endPoint.real, segment.endPoint.imag))
-            elif segment.command == "L":
-                pen.lineTo((segment.endPoint.real, segment.endPoint.imag))
-            elif segment.command == "C":
+    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.ctrl1.real, segment.ctrl1.imag),
-                     (segment.ctrl2.real, segment.ctrl2.imag),
-                     (segment.endPoint.real, segment.endPoint.imag))
+                    (segment.control1.real, segment.control1.imag),
+                    (segment.control2.real, segment.control2.imag),
+                    (end.real, end.imag)
                 )
-            elif segment.command == "Z":
                 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
 
 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)
-        try:
-            parse_svg_path(path_data.strip(), glyph)
-            glyph.width = 600  # largeur du glyphe
-        except Exception as e:
-            print(f"Erreur injection SVG pour {letter}: {e}")
+        add_svg_to_glyph(glyph, path_data)
         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
 
 # ------------------------
@@ -140,15 +155,19 @@ def respond(message: str, system_message: str, max_tokens: int, temperature: flo
     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,
@@ -162,8 +181,10 @@ def respond(message: str, system_message: str, max_tokens: int, temperature: flo
         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
@@ -179,6 +200,7 @@ def create_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")
@@ -192,15 +214,19 @@ def create_demo():
                 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)
@@ -211,31 +237,38 @@ def create_demo():
                     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()