Update app.py

app.py

@@ -1,221 +1,156 @@
-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 tempfile
 import glob
-from fontmake.font_project import FontProject
-from defcon import Font, Glyph, Point
-from fontTools.pens.svgPathPen import SVGPathPen
-from svgpathtools import parse_path, Path, Line, CubicBezier, QuadraticBezier, Arc
-from svgpathtools.path import Path as SvgPath
-from svgpathtools.path import BoundingBox  # Importation de BoundingBox pour gérer les limites
-
-# ------------------------
-# MODELE
-# ------------------------
+import subprocess
+import zipfile
+from defcon import Font, Glyph
+from svgpathtools import parse_path, Path, Line, CubicBezier, Move
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
+import torch
+from threading import Thread
+
 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 validate_svg_path(path_data):
-    try:
-        parse_path(path_data)
-        return True
-    except Exception as e:
-        print(f"Invalid SVG path: {e}")
-        return False
-
 def build_ufo_from_glyphs(glyphs):
     font = Font()
     font.info.familyName = "TipTopType"
     font.info.styleName = "Regular"
     font.info.unitsPerEm = 1000
     font.info.ascender = 800
-    font.info.descender = -200
+    font.info.descender = -300
     font.info.capHeight = 700
     font.info.xHeight = 500
+
     for letter, path_data in glyphs:
-        if not validate_svg_path(path_data):
-            print(f"Skipping glyph {letter} due to invalid SVG path.")
-            continue
-        glyph = Glyph()
-        glyph.name = letter
-        glyph.unicode = ord(letter)
-        pen = glyph.getPen()
+        print(f"\n--- Processing glyph: {letter} ---")
         try:
             path = parse_path(path_data)
-            normalized_path = []
+            if not path:
+                print(f"❌ Skipping {letter}: could not parse path")
+                continue
+
+            glyph = Glyph()
+            glyph.name = letter
+            glyph.unicode = ord(letter)
+            pen = glyph.getPen()
+
             for segment in path:
-                if segment.length() == 0:
-                    continue
-                normalized_path.append(segment)
-            if normalized_path:
-                # Calculer les limites du chemin
-                bounds = None
-                for segment in normalized_path:
-                    segment_bounds = BoundingBox([segment.start, segment.end])
-                    if isinstance(segment, (CubicBezier, QuadraticBezier)):
-                        segment_bounds |= BoundingBox([segment.control1, segment.control2])
-                    if bounds is None:
-                        bounds = segment_bounds
-                    else:
-                        bounds |= segment_bounds
-                if bounds and (bounds.width > 0) and (bounds.height > 0):
-                    glyph_width = 800
-                    glyph_height = 1000
-                    scale_factor = glyph_height * 0.8 / bounds.height
-                    offset_x = (glyph_width - bounds.width * scale_factor) / 2
-                    offset_y = -bounds.bottom * scale_factor
-                    def transform_point(point):
-                        x = point.real
-                        y = point.imag
-                        new_x = x * scale_factor + offset_x
-                        new_y = y * scale_factor + offset_y
-                        return Point((new_x, -new_y))
-                    if normalized_path:
-                        start_segment = normalized_path[0]
-                        start_point = transform_point(start_segment.start)
-                        pen.moveTo(start_point)
-                        for segment in normalized_path:
-                            if isinstance(segment, Line):
-                                end_point = transform_point(segment.end)
-                                pen.lineTo(end_point)
-                            elif isinstance(segment, CubicBezier):
-                                control1 = transform_point(segment.control1)
-                                control2 = transform_point(segment.control2)
-                                end_point = transform_point(segment.end)
-                                pen.curveTo(control1, control2, end_point)
-                            elif isinstance(segment, QuadraticBezier):
-                                control = transform_point(segment.control)
-                                end_point = transform_point(segment.end)
-                                # Approximer la courbe quadratique avec une courbe cubique
-                                start_point = transform_point(segment.start)
-                                control1 = start_point + (control - start_point) * 2/3
-                                control2 = end_point + (control - end_point) * 2/3
-                                pen.curveTo(control1, control2, end_point)
-                        if normalized_path and normalized_path[-1].end == normalized_path[0].start:
-                            pen.closePath()
-            glyph.width = glyph_width if 'glyph_width' in locals() else 1000
-            print(f"Glyph {letter} created with SVG path.")
-        except Exception as e:
-            print(f"Error injecting SVG for {letter}: {e}")
-            pen.moveTo(Point((100, 0)))
-            pen.lineTo(Point((900, 0)))
-            pen.lineTo(Point((900, 1000)))
-            pen.lineTo(Point((100, 1000)))
-            pen.closePath()
+                if isinstance(segment, Move):
+                    pen.moveTo((segment.end.real, -segment.end.imag))
+                elif isinstance(segment, Line):
+                    pen.lineTo((segment.end.real, -segment.end.imag))
+                elif isinstance(segment, CubicBezier):
+                    pen.curveTo(
+                        (segment.control1.real, -segment.control1.imag),
+                        (segment.control2.real, -segment.control2.imag),
+                        (segment.end.real, -segment.end.imag)
+                    )
+
             glyph.width = 1000
-        font.insertGlyph(glyph)
-    print(f"Total glyphs in font: {len(font)}")
+            font.insertGlyph(glyph)
+            print(f"✅ Glyph {letter} added successfully")
+
+        except Exception as e:
+            print(f"❌ Error for {letter}: {str(e)}")
+            continue
+
+    print(f"\nTotal glyphs in UFO: {len(font)}")
     return font
 
 def save_otf_font(glyphs, font_name="TipTopType-Regular.otf"):
-    if not glyphs:
-        print("No glyphs provided to generate OTF font.")
-        return None
     try:
         with tempfile.TemporaryDirectory() as tmpdir:
             ufo_path = os.path.join(tmpdir, "font.ufo")
             font = build_ufo_from_glyphs(glyphs)
             font.save(ufo_path)
-            print(f"UFO file saved at: {ufo_path}")
+            print(f"UFO saved to: {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)
-            print("Fontmake ran successfully.")
-            otf_files = glob.glob(os.path.join(output_dir, "**/*.otf"), recursive=True)
+
+            result = subprocess.run(
+                ["fontmake", "-o", "otf", ufo_path, "--output-dir", output_dir],
+                capture_output=True,
+                text=True
+            )
+            print("FontMake output:", result.stdout)
+            print("FontMake errors:", result.stderr)
+
+            otf_files = glob.glob(os.path.join(output_dir, "*.otf"))
             if not otf_files:
-                print("No OTF files generated by fontmake.")
+                print("❌ No OTF generated")
                 return None
-            generated_path = otf_files[0]
-            print(f"OTF file generated at: {generated_path}")
+
             final_path = os.path.join(tempfile.gettempdir(), font_name)
-            os.replace(generated_path, final_path)
-            print(f"OTF file moved to: {final_path}")
+            os.replace(otf_files[0], final_path)
+            print(f"✅ OTF saved to: {final_path}")
             return final_path
+
     except Exception as e:
-        print(f"Error in save_otf_font: {e}")
+        print(f"❌ Error in save_otf_font: {str(e)}")
         return None
 
-# ------------------------
-# GENERATION
-# ------------------------
-@spaces.GPU(duration=180)
-def respond(message: str, system_message: str, max_tokens: int, temperature: float, top_p: float):
+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
+
+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 respond(message, system_message, max_tokens, temperature, top_p):
     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,
@@ -226,12 +161,15 @@ def respond(message: str, system_message: str, max_tokens: int, temperature: flo
         "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
@@ -239,17 +177,15 @@ def respond(message: str, system_message: str, max_tokens: int, temperature: flo
         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")
+                msg = gr.Textbox(label="Input description of the typography")
                 system_message = gr.Textbox(
                     value="Based on the following text, give me the svgpath of the glyphs from A to Z.",
                     visible=False
@@ -260,15 +196,17 @@ 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_btn = gr.Button("Download SVG files")
                 download_otf_btn = gr.Button("Download OTF font")
             with gr.Column(scale=3):
-                gr.Markdown("## preview")
+                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)
@@ -279,25 +217,30 @@ 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()