Update app.py

app.py

@@ -1,3 +1,4 @@
+```python
 import spaces
 from transformers import AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer
 import gradio as gr
@@ -9,10 +10,10 @@ import zipfile
 import tempfile
 import os
 from fontTools.ttLib import TTFont
-from fontTools.ttLib.tables import ttProgram
-from fontTools.ttLib.tables._c_m_a_p import CmapSubtable
-from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
-from fontTools.pens.ttGlyphPen import TTGlyphPen
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.t2CharStringPen import T2CharStringPen
+from fontTools.cffLib import PrivateDict
+import traceback
 
 def load_model():
     tokenizer = AutoTokenizer.from_pretrained("ChevalierJoseph/typtop")
@@ -60,53 +61,190 @@ def generate_svg_files(glyphs, width=100, height=100):
         svg_files[f"{lettre}.svg"] = svg_content
     return svg_files
 
-def create_otf_font(glyphs, output_path="font.otf"):
-    font = TTFont()
-
-    # Ajouter les tables nécessaires
-    font['head'] = TTFont.Table('head')
-    font['hhea'] = TTFont.Table('hhea')
-    font['maxp'] = TTFont.Table('maxp')
-    font['name'] = TTFont.Table('name')
-    font['OS/2'] = TTFont.Table('OS/2')
-    font['post'] = TTFont.Table('post')
-    font['hmtx'] = TTFont.Table('hmtx')
-    font['cmap'] = TTFont.Table('cmap')
-    font['glyf'] = TTFont.Table('glyf')
-
-    # Configurer les champs obligatoires pour chaque table
-    font['head'].fontRevision = 1.0
-    font['hhea'].ascent = 800
-    font['hhea'].descent = -200
-    font['hhea'].lineGap = 0
-    font['maxp'].numGlyphs = len(glyphs)
-
-    # Créer une table cmap pour mapper les caractères Unicode aux glyphe
-    cmap_table = CmapSubtable.newSubtable(3, 1, 0)  # Windows platform, Unicode BMP encoding
-    cmap_table.cmap = {}
-    font['cmap'].tables = [cmap_table]
-
-    # Ajouter chaque glyphe à la police
-    glyf_table = font['glyf']
-    hmtx_table = font['hmtx']
-
-    for lettre, path in glyphs:
-        unicode_val = ord(lettre)
-        glyph_name = f"glyph{unicode_val}"
-
-        # Créer un glyphe vide (pour un exemple simple)
-        glyph = glyf_table.glyphClass()
-        glyph.name = glyph_name
-        glyf_table[glyph_name] = glyph
+def draw_svg_path(pen, path_string):
+    """
+    Parse SVG path string and draw it using the given pen.
+    Args:
+        pen: The drawing pen
+        path_string (str): SVG path string
+    """
+    # Simple SVG path parser - handles basic commands
+    # This is a simplified version - you might need to extend it for complex paths
+    commands = re.findall(r'[MLHVCSQTAZmlhvcsqtaz][^MLHVCSQTAZmlhvcsqtaz]*', path_string)
+    current_x, current_y = 0, 0
+    for command in commands:
+        cmd = command[0]
+        coords = re.findall(r'-?\d+(?:\.\d+)?', command[1:])
+        coords = [float(c) for c in coords]
+        if cmd == 'M':  # Move to (absolute)
+            if len(coords) >= 2:
+                current_x, current_y = coords[0], -coords[1]  # Inverser l'axe Y
+                pen.moveTo((current_x, current_y))
+        elif cmd == 'm':  # Move to (relative)
+            if len(coords) >= 2:
+                current_x += coords[0]
+                current_y -= coords[1]  # Inverser l'axe Y
+                pen.moveTo((current_x, current_y))
+        elif cmd == 'L':  # Line to (absolute)
+            for i in range(0, len(coords), 2):
+                if i + 1 < len(coords):
+                    current_x, current_y = coords[i], -coords[i + 1]  # Inverser l'axe Y
+                    pen.lineTo((current_x, current_y))
+        elif cmd == 'l':  # Line to (relative)
+            for i in range(0, len(coords), 2):
+                if i + 1 < len(coords):
+                    current_x += coords[i]
+                    current_y -= coords[i + 1]  # Inverser l'axe Y
+                    pen.lineTo((current_x, current_y))
+        elif cmd == 'H':  # Horizontal line to (absolute)
+            for x in coords:
+                current_x = x
+                pen.lineTo((current_x, current_y))
+        elif cmd == 'h':  # Horizontal line to (relative)
+            for dx in coords:
+                current_x += dx
+                pen.lineTo((current_x, current_y))
+        elif cmd == 'V':  # Vertical line to (absolute)
+            for y in coords:
+                current_y = -y  # Inverser l'axe Y
+                pen.lineTo((current_x, current_y))
+        elif cmd == 'v':  # Vertical line to (relative)
+            for dy in coords:
+                current_y -= dy  # Inverser l'axe Y
+                pen.lineTo((current_x, current_y))
+        elif cmd == 'C':  # Cubic bezier curve (absolute)
+            for i in range(0, len(coords), 6):
+                if i + 5 < len(coords):
+                    x1, y1 = coords[i], -coords[i + 1]  # Inverser l'axe Y
+                    x2, y2 = coords[i + 2], -coords[i + 3]  # Inverser l'axe Y
+                    current_x, current_y = coords[i + 4], -coords[i + 5]  # Inverser l'axe Y
+                    pen.curveTo((x1, y1), (x2, y2), (current_x, current_y))
+        elif cmd == 'c':  # Cubic bezier curve (relative)
+            for i in range(0, len(coords), 6):
+                if i + 5 < len(coords):
+                    x1 = current_x + coords[i]
+                    y1 = current_y - coords[i + 1]  # Inverser l'axe Y
+                    x2 = current_x + coords[i + 2]
+                    y2 = current_y - coords[i + 3]  # Inverser l'axe Y
+                    current_x += coords[i + 4]
+                    current_y -= coords[i + 5]  # Inverser l'axe Y
+                    pen.curveTo((x1, y1), (x2, y2), (current_x, current_y))
+        elif cmd in ['Z', 'z']:  # Close path
+            pen.closePath()
+    pen.endPath()
 
-        # Mapper le code Unicode au nom du glyphe
-        cmap_table.cmap[unicode_val] = glyph_name
-        # Définir les métriques pour chaque glyphe
-        hmtx_table[glyph_name] = (1000, 0)  # (advanceWidth, leftSideBearing)
+def create_otf_font(glyphs, output_path="font.otf"):
+    glyph_paths = {lettre: path for lettre, path in glyphs}
+
+    # Add default .notdef if not present (simple rectangle)
+    default_notdef_path = "M50 700H450V0H50Z M100 600L400 100 M400 600L100 100"  # Box with X, Y down for SVG
+    if '.notdef' not in glyph_paths:
+        glyph_paths['.notdef'] = default_notdef_path
+
+    # Prepare glyph order
+    glyph_names = list(glyph_paths.keys())
+    if glyph_names[0] != '.notdef':
+        glyph_names.insert(0, '.notdef')  # Ensure .notdef is first
+
+    # Prepare Unicode mapping
+    unicode_map = {}
+    for glyph_name in glyph_paths:
+        if len(glyph_name) == 1 and glyph_name.isalpha():
+            unicode_value = ord(glyph_name.upper())
+            unicode_map[unicode_value] = glyph_name
+
+    # Prepare PrivateDict with defaults
+    private_dict = PrivateDict()
+    private_dict.nominalWidthX = 600
+    private_dict.defaultWidthX = 600
+    private_dict.blueValues = []
+    private_dict.otherBlues = []
+    private_dict.familyBlues = []
+    private_dict.familyOtherBlues = []
+    private_dict.BlueScale = 0.039625
+    private_dict.BlueShift = 7
+    private_dict.BlueFuzz = 1
+    private_dict.StdHW = [100]
+    private_dict.StdVW = [100]
+
+    # Create charstrings
+    char_strings = {}
+    for glyph_name, svg_path in glyph_paths.items():
+        try:
+            pen = T2CharStringPen(600, None)  # Width 600, no glyphSet yet
+            draw_svg_path(pen, svg_path)
+            charstring = pen.getCharString(private=private_dict)
+            char_strings[glyph_name] = charstring
+        except Exception as e:
+            print(f"Error converting glyph {glyph_name}: {e}")
+            traceback.print_exc()
+
+    # Prepare font names
+    new_font_name = "Custom Glyph Font"
+    family_name = new_font_name
+    style_name = "Regular"
+    full_name = f"{family_name} {style_name}"
+    ps_name = f"{family_name.replace(' ', '')}-{style_name}"
+    name_strings = {
+        "familyName": family_name,
+        "styleName": style_name,
+        "fullName": full_name,
+        "psName": ps_name,
+        # Add more localized if needed
+    }
 
-    # Sauvegarder la police
-    font.save(output_path)
-    return output_path
+    # Setup FontBuilder
+    try:
+        fb = FontBuilder(1000, isTTF=False)  # unitsPerEm=1000, OTF (CFF)
+        fb.setupGlyphOrder(glyph_names)
+        fb.setupCharacterMap(unicode_map)
+
+        # Setup CFF table with privateDicts
+        top_dict_data = {"FullName": full_name}
+        fb.setupCFF(ps_name, top_dict_data, char_strings, {ps_name: private_dict})
+
+        # Calculate metrics with debug
+        advance_widths = {gn: 600 for gn in glyph_names}
+        metrics = {}
+        max_ascent = 0
+        min_descent = 0
+        for gn, cs in char_strings.items():
+            try:
+                bounds = cs.calcBounds(None)
+                lsb = int(round(bounds[0])) if bounds else 0
+                if bounds:
+                    max_ascent = max(max_ascent, int(round(bounds[3])))
+                    min_descent = min(min_descent, int(round(bounds[1])))
+                metrics[gn] = (advance_widths[gn], lsb)
+            except Exception as e:
+                print(f"Error calculating bounds for {gn}: {e}")
+                traceback.print_exc()
+                metrics[gn] = (advance_widths[gn], 0)  # Fallback
+
+        fb.setupHorizontalMetrics(metrics)
+        # Adjust ascent/descent based on glyphs if possible
+        ascent = max(800, max_ascent)
+        descent = min(-200, min_descent)
+        fb.setupHorizontalHeader(ascent=ascent, descent=descent)
+        fb.setupNameTable(name_strings)
+        fb.setupOS2()
+        fb.setupPost()
+    except Exception as e:
+        print(f"Error building font: {e}")
+        traceback.print_exc()
+        return None
+
+    # Save the font
+    try:
+        fb.save(output_path)
+        # Basic validation
+        test_font = TTFont(output_path)
+        test_font.close()
+        return output_path
+    except Exception as e:
+        print(f"Error saving font: {e}")
+        traceback.print_exc()
+        return None
 
 def create_zip(svg_files):
     with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp_file:
@@ -226,8 +364,13 @@ def create_demo():
         def export_to_otf(glyphs):
             if not glyphs:
                 return None
-            otf_path = create_otf_font(glyphs)
-            return otf_path
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".otf") as tmp_file:
+                otf_path = tmp_file.name
+            created_path = create_otf_font(glyphs, otf_path)
+            if created_path:
+                return created_path
+            else:
+                return None
 
         msg.submit(
             user, [msg, message_history], [msg, message_history], queue=False
@@ -255,3 +398,4 @@ demo = create_demo()
 
 if __name__ == "__main__":
     demo.launch()
+```