Update app.py

app.py

@@ -1,88 +1,78 @@
-import re
-import os
-import tempfile
-import zipfile
-from fontTools.ttLib import TTFont
-from svgpathtools import parse_path, Path, Line, CubicBezier, Arc
-from svgpathtools.path import Move  # Importation correct
-import gradio as gr
+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 subprocess
 
 def load_model():
     tokenizer = AutoTokenizer.from_pretrained("ChevalierJoseph/typtop")
     model = AutoModelForCausalLM.from_pretrained("ChevalierJoseph/typtop")
     return tokenizer, model
 
+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 build_glyph_outlines(glyphs):
-    outlines = {}
-    for letter, path_data in glyphs:
-        path = parse_path(path_data)
-        outlines[letter] = path
-    return outlines
-
-def generate_otf_directly(glyphs, output_path="output.otf"):
-    font = TTFont()
-
-    # Ajoutez une table cmap simple pour Unicode
-    cmap = font["cmap"] = ttLib.tables.c_m_a_p.CmapTable()
-    cmap.tables = [ttLib.tables.c_m_a_p.CmapSubtable.newSubtable(3, 1, 0)]
-
-    # Ajoutez une table hmtx simple
-    font["hmtx"] = ttLib.tables.h_m_t_x.hmtx()
-    font["hmtx"].metrics = {}
-
-    # Ajoutez une table maxp simple
-    font["maxp"] = ttLib.tables.m_a_x_p.maxp()
-    font["maxp"].numGlyphs = len(glyphs)
-
-    # Ajoutez une table head simple
-    font["head"] = ttLib.tables.h_e_a_d.head()
-    font["head"].unitsPerEm = 1000
-
-    # Ajoutez une table hhea simple
-    font["hhea"] = ttLib.tables.h_h_e_a.hhea()
-    font["hhea"].ascent = 800
-    font["hhea"].descent = -300
-
-    # Ajoutez une table loca simple
-    font["loca"] = ttLib.tables.loca.loca()
-
-    for letter, path_data in glyphs:
-        glyph_name = f"glyph_{ord(letter)}"
-        # Créez un glyphe vide
-        glyph = ttLib.tables.g_l_y_f.Glyph()
-        glyph.numberOfContours = 0  # Placeholder
-        font["glyf"][glyph_name] = glyph
-
-        # Ajoutez des métriques pour le glyphe
-        font["hmtx"].metrics[glyph_name] = (1000, 0)
-
-        # Ajoutez une entrée cmap pour le glyphe
-        cmap.tables[0].cmap[ord(letter)] = glyph_name
+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>")
 
-    font.save(output_path)
-    return output_path
+    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>
+            <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_font_svg(glyphs, output_path="font.svg"):
+    with open(output_path, 'w') as font_file:
+        font_file.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
+        for lettre, path in glyphs:
+            unicode_val = ord(lettre)
+            font_file.write(f'  <glyph unicode="&#{unicode_val};" d="{path.strip()}"/>\n')
+        font_file.write('</svg>\n')
+    return output_path
+
+def convert_svg_to_otf(svg_path, otf_path="font.otf"):
+    try:
+        subprocess.run(['svg2ttf', svg_path, otf_path], check=True)
+        return otf_path
+    except subprocess.CalledProcessError as e:
+        print(f"Error in converting SVG to OTF: {e}")
+        return None
+
 def create_zip(svg_files):
     with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp_file:
         zip_path = tmp_file.name
@@ -91,21 +81,8 @@ def create_zip(svg_files):
             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):
+@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')
@@ -113,29 +90,30 @@ def respond(message, system_message, max_tokens, temperature, top_p):
 
     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",
+        messages, tokenize=True, add_generation_prompt=True, return_tensors="pt",
     ).to(model_device)
 
     streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+    do_sample_effective = True
+    if temperature == 0.0:
+        pass
     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,
+        "do_sample": do_sample_effective,
         "use_cache": True,
     }
-
     if temperature <= 0.01:
         generation_kwargs["do_sample"] = False
-        generation_kwargs.pop("temperature", None)
-        generation_kwargs.pop("top_p", None)
+    if "temperature" in generation_kwargs:
+        del generation_kwargs["temperature"]
+    if "top_p" in generation_kwargs:
+        del generation_kwargs["top_p"]
 
     thread = Thread(target=model.generate, kwargs=generation_kwargs)
     thread.start()
@@ -145,6 +123,7 @@ def respond(message, system_message, max_tokens, temperature, top_p):
         partial_response += new_text
         glyphs = extract_glyphs(partial_response)
         yield partial_response, glyphs
+
     thread.join()
 
 def create_demo():
@@ -152,26 +131,39 @@ 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 description of the typography")
+                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 files")
-                download_otf_btn = gr.Button("Download OTF font")
+                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")
+                otf_export_btn = gr.Button("Export OTF")
+
             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]]
@@ -184,7 +176,9 @@ def create_demo():
                 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."
+                    svg_html = generate_glyphs_html(glyphs_list, cols=cols, width=width, height=height)
+                else:
+                    svg_html = "No glyphs found."
                 yield svg_html, glyphs_list
 
         def download_svg(glyphs, width, height):
@@ -194,24 +188,36 @@ def create_demo():
             zip_path = create_zip(svg_files)
             return zip_path
 
-        def download_otf(glyphs):
+        def export_to_otf(glyphs):
             if not glyphs:
                 return None
-            return generate_otf_directly(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]
+            svg_path = create_font_svg(glyphs)
+            otf_path = convert_svg_to_otf(svg_path)
+            return otf_path
+
+        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_svg,
+            inputs=[glyphs_state, width, height],
+            outputs=download_output
         )
-        download_otf_btn.click(
-            download_otf, inputs=[glyphs_state], outputs=download_otf_output
+
+        otf_export_btn.click(
+            export_to_otf,
+            inputs=[glyphs_state],
+            outputs=download_output
         )
 
-    return demo
+        return demo
 
 demo = create_demo()
+
 if __name__ == "__main__":
     demo.launch()