Update app.py

app.py

@@ -1,437 +1,309 @@
-import os, re, io
-import xml.etree.ElementTree as ET
 import gradio as gr
-
-from hand import Hand  # your handwriting model wrapper
-
-# ---------------------------------- Setup ------------------------------------
+import os
+import threading
+import subprocess
+import time
+import re
+from huggingface_hub import hf_hub_download
+from handwriting_api import InputData, validate_input
+from hand import Hand
+
+# Create img directory if it doesn't exist
 os.makedirs("img", exist_ok=True)
-hand = Hand()
-
-# ------------------------------ SVG / coords ---------------------------------
-def _parse_viewbox(root):
-    vb = root.get("viewBox")
-    if vb:
-        s = re.sub(r"[,\s]+", " ", vb.strip())
-        parts = [p for p in s.split(" ") if p]
-        if len(parts) == 4:
-            try:
-                x, y, w, h = map(float, parts)
-                if w <= 0: w = 1200.0
-                if h <= 0: h = 400.0
-                return (x, y, w, h)
-            except ValueError:
-                pass
-    def _num(v, d):
-        if not v: return float(d)
-        v = v.strip().lower().replace("px", "").replace(",", ".")
-        try: return float(v)
-        except: return float(d)
-    w = _num(root.get("width"), 1200.0)
-    h = _num(root.get("height"), 400.0)
-    return (0.0, 0.0, w, h)
-
-def _px_to_svg_x(x_px, img_w, vb):
-    vx, vy, vw, vh = vb
-    if img_w <= 0: return vx
-    return vx + (x_px / float(img_w)) * vw
-
-def _px_to_svg_y(y_px, img_h, vb):
-    vx, vy, vw, vh = vb
-    if img_h <= 0: return vy
-    return vy + (y_px / float(img_h)) * vh
-
-def _extract_paths(elem):
-    return [e for e in elem.iter() if e.tag.endswith("path")]
-
-def _translate_group(elem, dx, dy):
-    prev = elem.get("transform", "")
-    elem.set("transform", (prev + f" translate({dx},{dy})").strip())
-
-# ----------------------------- Tokenization ----------------------------------
-def _tokenize_line(line):
-    tokens, i, n = [], 0, len(line)
-    while i < n:
-        ch = line[i]
-        if ch == "_":
-            j = i
-            while j < n and line[j] == "_": j += 1
-            tokens.append(("sep_underscore", line[i:j]))
-            i = j
-        elif ch.isspace():
-            j = i
-            while j < n and line[j].isspace(): j += 1
-            tokens.append(("sep_space", line[i:j]))
-            i = j
-        else:
-            j = i
-            while j < n and (line[j] != "_" and not line[j].isspace()):
-                j += 1
-            tokens.append(("text", line[i:j]))
-            i = j
-    return tokens
-
-def _display_text_from_tokens(tokens):
-    return "".join([v if t == "text" else " " for t, v in tokens])
-
-# ------------------------ Rasterization & analysis ---------------------------
-def _rasterize_svg(svg_str, scale=3.0):
-    import cairosvg
-    from PIL import Image
-    png = cairosvg.svg2png(bytestring=svg_str.encode("utf-8"), scale=scale, background_color="none")
-    return Image.open(io.BytesIO(png)).convert("RGBA")
-
-def _find_blobs_and_gaps(alpha_img):
-    w, h = alpha_img.size
-    bbox = alpha_img.getbbox()
-    if not bbox:
-        return [], [], (0, 0, w, h)
-    left, top, right, bottom = bbox
-
-    def col_has_ink(x):
-        for y in range(top, bottom):
-            if alpha_img.getpixel((x, y)) > 0:
-                return True
-        return False
 
-    blobs, gaps = [], []
-    x = left
-    in_blob = col_has_ink(x)
-    start = x
-    while x < right:
-        has = col_has_ink(x)
-        if has != in_blob:
-            if in_blob: blobs.append((start, x))
-            else: gaps.append((start, x))
-            start, in_blob = x, has
-        x += 1
-    if in_blob: blobs.append((start, right))
-    else: gaps.append((start, right))
-
-    core_gaps = [(blobs[i][1], blobs[i + 1][0]) for i in range(len(blobs) - 1)]
-    return blobs, core_gaps, (left, top, right, bottom)
-
-def _column_profile(alpha_img, top, bottom):
-    w, h = alpha_img.size
-    prof = [0] * w
-    for x in range(w):
-        s = 0
-        for y in range(top, bottom):
-            if alpha_img.getpixel((x, y)) > 0:
-                s += 1
-        prof[x] = s
-    return prof
-
-def _synthesize_gap_near(alpha_img, content_bbox, target_x_px, min_w_px=14, search_pct=0.18):
-    left, top, right, bottom = content_bbox
-    prof = _column_profile(alpha_img, top, bottom)
-    half = max(6, int((right - left) * search_pct))
-    x0 = max(left + 1, int(target_x_px - half))
-    x1 = min(right - 1, int(target_x_px + half))
-    best_x, best_v = x0, prof[x0]
-    for x in range(x0, x1):
-        v = prof[x]
-        if v < best_v:
-            best_x, best_v = x, v
-    half_w = max(7, min_w_px // 2)
-    g0 = max(left + 1, best_x - half_w)
-    g1 = min(right - 1, best_x + half_w)
-    if g1 - g0 < min_w_px:
-        pad = (min_w_px - (g1 - g0)) // 2 + 1
-        g0 = max(left + 1, g0 - pad)
-        g1 = min(right - 1, g1 + pad)
-    return (g0, g1)
-
-def _draw_underscores_in_gap(root, gap_px, baseline_px, img_w, img_h, vb,
-                             color, stroke_width, n, between_px=3.0,
-                             min_len=10.0, max_len=48.0, frac_of_gap=0.60):
-    gap_w = max(0.0, gap_px[1] - gap_px[0])
-    if gap_w <= 2.0 or n <= 0:
-        return
-    u_len = max(min_len, min(max_len, frac_of_gap * gap_w))
-    total_needed = n * u_len + (n - 1) * between_px
-    if total_needed > gap_w:
-        scale = gap_w / max(1.0, total_needed)
-        u_len *= scale
-    block_w = n * u_len + (n - 1) * between_px
-    x0_px = gap_px[0] + (gap_w - block_w) / 2.0  # center in gap
-    for i in range(n):
-        xs = x0_px + i * (u_len + between_px)
-        xe = xs + u_len
-        x0 = _px_to_svg_x(xs, img_w, vb)
-        x1 = _px_to_svg_x(xe, img_w, vb)
-        y  = _px_to_svg_y(baseline_px, img_h, vb)
-        p = ET.Element("path")
-        p.set("d", f"M{x0},{y} L{x1},{y}")
-        p.set("stroke", color)
-        p.set("stroke-width", str(max(1, stroke_width)))
-        p.set("fill", "none")
-        p.set("stroke-linecap", "round")
-        root.append(p)
-
-def _draw_margin_underscores(root, edge_px, side, baseline_px, img_w, img_h, vb,
-                             color, stroke_width, n, between_px=4.0, len_px=22.0, pad_px=6.0):
-    if n <= 0: return
-    for i in range(n):
-        if side == "left":
-            x1_px = edge_px - pad_px - i * (len_px + between_px)
-            x0_px = x1_px - len_px
-        else:
-            x0_px = edge_px + pad_px + i * (len_px + between_px)
-            x1_px = x0_px + len_px
-        x0 = _px_to_svg_x(x0_px, img_w, vb)
-        x1 = _px_to_svg_x(x1_px, img_w, vb)
-        y  = _px_to_svg_y(baseline_px, img_h, vb)
-        p = ET.Element("path")
-        p.set("d", f"M{x0},{y} L{x1},{y}")
-        p.set("stroke", color)
-        p.set("stroke-width", str(max(1, stroke_width)))
-        p.set("fill", "none")
-        p.set("stroke-linecap", "round")
-        root.append(p)
-
-# ----------------------- Core: one line w/ underscores -----------------------
-def render_line_svg_with_underscores(line, style, bias, color, stroke_width,
-                                     force_in_largest_gap=False):
-    # Tokenize original; render with underscores->spaces
-    tokens = _tokenize_line(line)
-    display_line = _display_text_from_tokens(tokens).replace("/", "-").replace("\\", "-")
-
-    # Render the full line once (keeps model spacing intact)
-    hand.write(
-        filename="img/line.tmp.svg",
-        lines=[display_line if display_line.strip() else " "],
-        biases=[bias], styles=[style],
-        stroke_colors=[color], stroke_widths=[stroke_width]
-    )
-    root = ET.parse("img/line.tmp.svg").getroot()
-    vb = _parse_viewbox(root)
-
-    # Put model paths into a group we'll augment
-    g = ET.Element("g")
-    for p in _extract_paths(root):
-        g.append(p)
-
-    # Rasterize & analyze
-    img = _rasterize_svg(ET.tostring(root, encoding="unicode"), scale=3.0)
-    alpha = img.split()[-1]
-    blobs, gaps, content_bbox = _find_blobs_and_gaps(alpha)
-    img_w, img_h = img.size
-    left, top, right, bottom = content_bbox
-    line_h_px = max(20, bottom - top)
-    baseline_px = bottom - int(0.18 * line_h_px)
-
-    # Count leading/trailing underscores
-    leading_us = 0
-    i = 0
-    while i < len(tokens) and tokens[i][0] != "text":
-        if tokens[i][0] == "sep_underscore":
-            leading_us += len(tokens[i][1])
-        i += 1
-    trailing_us = 0
-    j = len(tokens) - 1
-    while j >= 0 and tokens[j][0] != "text":
-        if tokens[j][0] == "sep_underscore":
-            trailing_us += len(tokens[j][1])
-        j -= 1
+# Initialize the handwriting model
+hand = Hand()
 
-    # Build clusters (positions between text runs) + underscore counts
-    clusters = []
-    i = 0
-    while i < len(tokens):
-        t, v = tokens[i]
-        if t == "text" and len(v) > 0:
-            j = i + 1
-            u_count, saw_sep = 0, False
-            while j < len(tokens) and tokens[j][0].startswith("sep_"):
-                saw_sep = True
-                if tokens[j][0] == "sep_underscore":
-                    u_count += len(tokens[j][1])
-                j += 1
-            if saw_sep:
-                clusters.append({"underscores": u_count})
-            i = j
+# Create a function to generate handwriting
+def generate_handwriting(
+    text, 
+    style, 
+    bias=0.75, 
+    color="#000000",
+    stroke_width=2,
+    multiline=True,
+    transparent_background=True
+):
+    """Generate handwritten text using the model"""
+    try:
+        # Process the text
+        if multiline:
+            lines = text.split('\n')
         else:
-            i += 1
-
-    words = [v for (t, v) in tokens if t == "text" and len(v) > 0]
-    gaps_sorted_by_width = sorted(gaps, key=lambda ab: (ab[1] - ab[0]), reverse=True)
-    used_gaps = [False] * len(gaps)
-
-    def _take_gap_for_idx(idx):
-        # 1) same index gap if available
-        if 0 <= idx < len(gaps) and not used_gaps[idx]:
-            used_gaps[idx] = True; return gaps[idx]
-        # 2) widest unused real gap
-        for gp in gaps_sorted_by_width:
-            try:
-                real_idx = gaps.index(gp)
-            except ValueError:
-                continue
-            if not used_gaps[real_idx]:
-                used_gaps[real_idx] = True; return gp
-        # 3) synthesize near expected split
-        seen_chars = sum(len(w) for w in words[:idx + 1]) if words else 1
-        total_chars = sum(len(w) for w in words) or 1
-        ratio = min(0.95, max(0.05, seen_chars / float(total_chars)))
-        target_x_px = left + ratio * (right - left)
-        return _synthesize_gap_near(alpha, content_bbox, target_x_px)
-
-    # Draw interior underscores
-    drew_any = False
-    for idx, cluster in enumerate(clusters):
-        n = int(cluster["underscores"])
-        if n <= 0:
-            continue
-        gap_px = _take_gap_for_idx(idx)
-        _draw_underscores_in_gap(
-            g, gap_px, baseline_px, img_w, img_h, vb,
-            color, stroke_width, n,
-            between_px=3.0, min_len=10.0, max_len=48.0, frac_of_gap=0.60
+            lines = [text]
+            
+        # Create arrays for parameters
+        stroke_colors = [color] * len(lines)
+        stroke_widths = [stroke_width] * len(lines)
+        biases = [bias] * len(lines)
+        styles = [style] * len(lines)
+        
+        # Process each line to replace slashes with dashes
+        sanitized_lines = []
+        for line_num, line in enumerate(lines):
+            if len(line) > 75:
+                return f"Error: Line {line_num+1} is too long (max 75 characters)"
+            
+            # Replace slashes with dashes
+            sanitized_line = line.replace('/', '-').replace('\\', '-')
+            sanitized_lines.append(sanitized_line)
+        
+        data = InputData(
+            text='\n'.join(sanitized_lines),
+            style=style,
+            bias=bias,
+            stroke_colors=stroke_colors,
+            stroke_widths=stroke_widths
         )
-        drew_any = True
-
-    # Leading/trailing
-    if blobs:
-        first_left = blobs[0][0]
-        last_right = blobs[-1][1]
-        if leading_us:
-            _draw_margin_underscores(
-                g, first_left, "left", baseline_px, img_w, img_h, vb,
-                color, stroke_width, leading_us
-            )
-            drew_any = True
-        if trailing_us:
-            _draw_margin_underscores(
-                g, last_right, "right", baseline_px, img_w, img_h, vb,
-                color, stroke_width, trailing_us
-            )
-            drew_any = True
-
-    # Optional: force-draw one underscore in widest gap if user asked and none drawn
-    if force_in_largest_gap and not drew_any and gaps:
-        widest = max(gaps, key=lambda ab: (ab[1] - ab[0]))
-        _draw_underscores_in_gap(
-            g, widest, baseline_px, img_w, img_h, vb,
-            color, stroke_width, n=1,
-            between_px=0.0, min_len=12.0, max_len=48.0, frac_of_gap=0.70
+        
+        try:
+            validate_input(data)
+        except ValueError as e:
+            return f"Error: {str(e)}"
+        
+        # Generate the handwriting with sanitized lines
+        hand.write(
+            filename='img/output.svg',
+            lines=sanitized_lines,
+            biases=biases,
+            styles=styles,
+            stroke_colors=stroke_colors,
+            stroke_widths=stroke_widths
         )
-
-    width_estimate = right - left if right > left else img_w // 2
-    return g, width_estimate
-
-# -------------------------- Multi-line compositor ----------------------------
-def generate_handwriting(text, style, bias=0.75, color="#000000", stroke_width=2,
-                         multiline=True, force=False):
-    try:
-        lines = text.split("\n") if multiline else [text]
-        for idx, ln in enumerate(lines):
-            if len(ln) > 75:
-                return f"Error: Line {idx+1} is too long (max 75 characters)"
-
-        svg_root = ET.Element("svg", {"xmlns": "http://www.w3.org/2000/svg", "viewBox": "0 0 1200 800"})
-        y0, line_gap, max_right = 80.0, 110.0, 0.0
-
-        for i, line in enumerate(lines):
-            g, w = render_line_svg_with_underscores(
-                line.replace("/", "-").replace("\\", "-"),
-                style, bias, color, stroke_width,
-                force_in_largest_gap=force
-            )
-            _translate_group(g, dx=40, dy=y0 + i * line_gap)
-            svg_root.append(g)
-            max_right = max(max_right, 40 + w)
-
-        height = int(y0 + len(lines) * line_gap + 80)
-        width = max(300, int(max_right + 40))
-        svg_root.set("viewBox", f"0 0 {width} {height}")
-
-        svg_content = ET.tostring(svg_root, encoding="unicode")
-        with open("img/output.svg", "w", encoding="utf-8") as f: f.write(svg_content)
+        
+        # Read the generated SVG
+        with open("img/output.svg", "r") as f:
+            svg_content = f.read()
+            
+        # If transparent background is requested, modify the SVG
+        if transparent_background:
+            # Remove the background rectangle or make it transparent
+            pattern = r'<rect[^>]*?fill="white"[^>]*?>'
+            if re.search(pattern, svg_content):
+                svg_content = re.sub(pattern, '', svg_content)
+            
+            # Write the modified SVG back
+            with open("img/output.svg", "w") as f:
+                f.write(svg_content)
+            
         return svg_content
     except Exception as e:
         return f"Error: {str(e)}"
 
-# ------------------------------- PNG export ----------------------------------
 def export_to_png(svg_content):
+    """Convert SVG to transparent PNG using CairoSVG and Pillow for robust transparency"""
     try:
         import cairosvg
         from PIL import Image
+        
         if not svg_content or svg_content.startswith("Error:"):
             return None
-        tmp_svg = "img/temp.svg"
-        with open(tmp_svg, "w", encoding="utf-8") as f: f.write(svg_content)
-        cairosvg.svg2png(url=tmp_svg, write_to="img/output_temp.png", scale=2.2, background_color="none")
+        
+        # Modify the SVG to ensure the background is transparent
+        # Remove any white background rectangle
+        pattern = r'<rect[^>]*?fill="white"[^>]*?>'
+        if re.search(pattern, svg_content):
+            svg_content = re.sub(pattern, '', svg_content)
+        
+        # Save the modified SVG to a temporary file
+        with open("img/temp.svg", "w") as f:
+            f.write(svg_content)
+            
+        # Convert SVG to PNG with transparency using CairoSVG
+        cairosvg.svg2png(
+            url="img/temp.svg", 
+            write_to="img/output_temp.png", 
+            scale=2.0,
+            background_color="none"  # This ensures transparency
+        )
+        
+        # Additional processing with Pillow to ensure transparency
         img = Image.open("img/output_temp.png")
-        if img.mode != "RGBA": img = img.convert("RGBA")
-        data = img.getdata()
-        img.putdata([(255,255,255,0) if r>240 and g>240 and b>240 else (r,g,b,a) for (r,g,b,a) in data])
-        out_path = "img/output.png"
-        img.save(out_path, "PNG")
-        try: os.remove("img/output_temp.png")
-        except: pass
-        return out_path
+        
+        # Convert to RGBA if not already
+        if img.mode != 'RGBA':
+            img = img.convert('RGBA')
+        
+        # Create a transparent canvas
+        transparent_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
+        
+        # Process the image data to ensure white is transparent
+        datas = img.getdata()
+        new_data = []
+        
+        for item in datas:
+            # If pixel is white or near-white, make it transparent
+            if item[0] > 240 and item[1] > 240 and item[2] > 240:
+                new_data.append((255, 255, 255, 0))  # Transparent
+            else:
+                new_data.append(item)  # Keep original color
+        
+        transparent_img.putdata(new_data)
+        transparent_img.save("img/output.png", "PNG")
+        
+        # Clean up the temporary file
+        try:
+            os.remove("img/output_temp.png")
+        except:
+            pass
+        
+        return "img/output.png"
     except Exception as e:
         print(f"Error converting to PNG: {str(e)}")
         return None
 
-# --------------------------------- UI ----------------------------------------
-def generate_handwriting_wrapper(text, style, bias, color, stroke_width, force):
-    svg = generate_handwriting(text, style, bias, color, stroke_width, multiline=True, force=force)
-    png = export_to_png(svg)
-    return svg, png, "img/output.svg"
+def generate_lyrics_sample():
+    """Generate a sample using lyrics"""
+    from lyrics import all_star
+    return all_star.split("\n")[0:4]
+    
+def generate_handwriting_wrapper(
+    text, 
+    style, 
+    bias, 
+    color, 
+    stroke_width,
+    multiline=True
+):
+    svg = generate_handwriting(text, style, bias, color, stroke_width, multiline)
+    png_path = export_to_png(svg)
+    return svg, png_path
 
 css = """
 .container {max-width: 900px; margin: auto;}
 .output-container {min-height: 300px;}
+.gr-box {border-radius: 8px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);}
+.footer {text-align: center; margin-top: 20px; font-size: 0.8em; color: #666;}
 """
 
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("# 🖋️ Handwriting Synthesis — Underscores in Real Gaps")
-    gr.Markdown("Spacing is the model’s own. We paint `_` *inside* the actual gaps. If needed, toggle force to drop one underscore into the widest gap.")
-
+    gr.Markdown("# 🖋️ Handwriting Synthesis")
+    gr.Markdown("Generate realistic handwritten text using neural networks.")
+    
     with gr.Row():
         with gr.Column(scale=2):
             text_input = gr.Textbox(
                 label="Text Input",
-                placeholder="Try: user_name, zeb_3asba, long__name, __init__",
-                lines=5
+                placeholder="Enter text to convert to handwriting...",
+                lines=5,
+                max_lines=10,
             )
+            
             with gr.Row():
-                style_select = gr.Slider(0, 12, step=1, value=9, label="Handwriting Style")
-                bias_slider = gr.Slider(0.5, 1.0, step=0.05, value=0.75, label="Neatness (Higher = Neater)")
+                with gr.Column(scale=1):
+                    style_select = gr.Slider(
+                        minimum=0, 
+                        maximum=12, 
+                        step=1, 
+                        value=9, 
+                        label="Handwriting Style"
+                    )
+                with gr.Column(scale=1):
+                    bias_slider = gr.Slider(
+                        minimum=0.5, 
+                        maximum=1.0, 
+                        step=0.05, 
+                        value=0.75, 
+                        label="Neatness (Higher = Neater)"
+                    )
+            
             with gr.Row():
-                color_picker = gr.ColorPicker(label="Ink Color", value="#000000")
-                stroke_width = gr.Slider(1, 4, step=0.5, value=2, label="Stroke Width")
-            force_toggle = gr.Checkbox(label="Force underscore in largest gap if none drawn", value=False)
-            generate_btn = gr.Button("Generate Handwriting", variant="primary")
+                with gr.Column(scale=1):
+                    color_picker = gr.ColorPicker(
+                        label="Ink Color", 
+                        value="#000000"
+                    )
+                with gr.Column(scale=1):
+                    stroke_width = gr.Slider(
+                        minimum=1, 
+                        maximum=4, 
+                        step=0.5, 
+                        value=2, 
+                        label="Stroke Width"
+                    )
+            
+            with gr.Row():
+                generate_btn = gr.Button("Generate Handwriting", variant="primary")
+                clear_btn = gr.Button("Clear")
+            
+            with gr.Accordion("Examples", open=False):
+                sample_btn = gr.Button("Insert Sample Text")
+            
         with gr.Column(scale=3):
             output_svg = gr.HTML(label="Generated Handwriting (SVG)", elem_classes=["output-container"])
             output_png = gr.Image(type="filepath", label="Generated Handwriting (PNG)", elem_classes=["output-container"])
-            download_svg_file = gr.File(label="Download SVG")
-            download_png_file = gr.File(label="Download PNG")
-
+            
+            with gr.Row():
+                download_svg_btn = gr.Button("Download SVG")
+                download_png_btn = gr.Button("Download PNG")
+    
+    gr.Markdown("""
+    ### Tips:
+    - Try different styles (0-12) to get various handwriting appearances
+    - Adjust the neatness slider to make writing more or less tidy
+    - Each line should be 75 characters or less
+    - The model works best for English text
+    - Forward slashes (/) and backslashes (\\) will be replaced with dashes (-)
+    - PNG output has transparency for easy integration into other documents
+    """)
+    
+    gr.Markdown("""
+    <div class="footer">
+    Created with Gradio • 
+    </div>
+    """)
+    
+    # Define interactions
     generate_btn.click(
         fn=generate_handwriting_wrapper,
-        inputs=[text_input, style_select, bias_slider, color_picker, stroke_width, force_toggle],
-        outputs=[output_svg, output_png, download_svg_file]
-    ).then(
-        fn=lambda p: p,
+        inputs=[text_input, style_select, bias_slider, color_picker, stroke_width],
+        outputs=[output_svg, output_png]
+    )
+    
+    clear_btn.click(
+        fn=lambda: ("", 9, 0.75, "#000000", 2),
+        inputs=None,
+        outputs=[text_input, style_select, bias_slider, color_picker, stroke_width]
+    )
+    
+    sample_btn.click(
+        fn=lambda: ("\n".join(generate_lyrics_sample())),
+        inputs=None,
+        outputs=[text_input]
+    )
+    
+    download_svg_btn.click(
+        fn=lambda x: x,
+        inputs=[output_svg],
+        outputs=[gr.File(label="Download SVG", file_count="single", file_types=[".svg"])]
+    )
+    
+    download_png_btn.click(
+        fn=lambda x: x,
         inputs=[output_png],
-        outputs=[download_png_file]
+        outputs=[gr.File(label="Download PNG", file_count="single", file_types=[".png"])]
     )
 
-# -------------------------------- main ---------------------------------------
 if __name__ == "__main__":
-    missing = []
+    # Set port based on environment variable or default to 7860
+    port = int(os.environ.get("PORT", 7860))
+    
+    # Check if required packages are installed
+    missing_packages = []
     try:
-        import cairosvg  # noqa
+        import cairosvg
     except ImportError:
-        missing.append("cairosvg")
+        missing_packages.append("cairosvg")
+    
     try:
-        from PIL import Image  # noqa
+        from PIL import Image
     except ImportError:
-        missing.append("pillow")
-    if missing:
-        print("Install:", " ".join(missing))
-    demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)))
+        missing_packages.append("pillow")
+    
+    if missing_packages:
+        print(f"WARNING: The following packages are missing and required for transparent PNG export: {', '.join(missing_packages)}")
+        print("Please install them using: pip install " + " ".join(missing_packages))
+    else:
+        print("All required packages are installed and ready for transparent PNG export")
+    
+    demo.launch(server_name="0.0.0.0", server_port=port)