sandbox.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "import base64\n",
    "from pathlib import Path\n",
    "import json\n",
    "from typing import Dict, List\n",
    "from openai import OpenAI\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "import time\n",
    "from io import BytesIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "from pathlib import Path\n",
    "import pandas as pd\n",
    "import csv\n",
    "from typing import Dict, List, Optional\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "class FontRenderer:\n",
    "    def __init__(self,\n",
    "                 base_directory: str,\n",
    "                 output_directory: str = \"rendered_fonts\",\n",
    "                 sample_texts: List[str] = None,\n",
    "                 image_size: tuple = (1200, 300),\n",
    "                 font_sizes: List[int] = None):\n",
    "        \"\"\"\n",
    "        Initialize the font renderer.\n",
    "        \n",
    "        Args:\n",
    "            base_directory: Base directory containing fonts and info.csv\n",
    "            output_directory: Directory to save rendered images\n",
    "            sample_texts: List of texts to render (will render each font with each text)\n",
    "            image_size: Size of the output image\n",
    "            font_sizes: List of font sizes to render\n",
    "        \"\"\"\n",
    "        self.base_directory = Path(base_directory)\n",
    "        self.output_directory = Path(output_directory)\n",
    "        self.sample_texts = sample_texts or [\n",
    "            \"The quick brown fox jumps over the lazy dog\",\n",
    "            \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\",\n",
    "            \"abcdefghijklmnopqrstuvwxyz\",\n",
    "            \"0123456789 !@#$%^&*()\",\n",
    "            \"Typography is the art and technique of arranging type\"\n",
    "        ]\n",
    "        self.image_size = image_size\n",
    "        self.font_sizes = font_sizes or [36]\n",
    "        \n",
    "        # Create output directory\n",
    "        self.output_directory.mkdir(parents=True, exist_ok=True)\n",
    "        \n",
    "        # Load font information\n",
    "        self.font_info = self._load_font_info()\n",
    "        \n",
    "    def _load_font_info(self) -> pd.DataFrame:\n",
    "        \"\"\"\n",
    "        Load and parse the info.csv file with proper handling of commas in fields.\n",
    "        Preserves all extra fields in the theme column.\n",
    "        \"\"\"\n",
    "        info_path = self.base_directory / \"info.csv\"\n",
    "        \n",
    "        try:\n",
    "            rows = []\n",
    "            with open(info_path, 'r', encoding='utf-8') as f:\n",
    "                reader = csv.reader(f, quoting=csv.QUOTE_MINIMAL, escapechar='\\\\')\n",
    "                headers = next(reader)  # Skip header row\n",
    "                \n",
    "                for row in reader:\n",
    "                    try:\n",
    "                        if len(row) >= 6:  # Must have at least the minimum required columns\n",
    "                            # Keep first 5 columns as is and combine all remaining columns into theme\n",
    "                            base_cols = row[:5]\n",
    "                            theme_cols = row[5:]\n",
    "                            theme = ','.join(theme_cols)  # Preserve all extra columns in theme\n",
    "                            rows.append(base_cols + [theme])\n",
    "                        else:\n",
    "                            print(f\"Warning: Row has too few columns, skipping: {row}\")\n",
    "                            \n",
    "                    except Exception as e:\n",
    "                        print(f\"Error processing row: {row}\")\n",
    "                        print(f\"Error: {str(e)}\")\n",
    "                        continue\n",
    "            \n",
    "            # Create DataFrame\n",
    "            df = pd.DataFrame(rows, columns=['filename', 'base_font_name', 'file_format', 'creator', 'category', 'theme'])\n",
    "            \n",
    "            # Clean up the data\n",
    "            df = df.apply(lambda x: x.str.strip() if isinstance(x, pd.Series) else x)\n",
    "            \n",
    "            # Remove any duplicate filenames\n",
    "            df = df.drop_duplicates(subset=['filename'], keep='first')\n",
    "            \n",
    "            # Sort by filename for consistent ordering\n",
    "            df = df.sort_values('filename')\n",
    "            \n",
    "            print(f\"Successfully loaded {len(df)} fonts from info.csv\")\n",
    "            return df\n",
    "            \n",
    "        except Exception as e:\n",
    "            print(f\"Error loading info.csv: {str(e)}\")\n",
    "            raise\n",
    "    \n",
    "    def _find_font_file(self, filename: str) -> Optional[Path]:\n",
    "        \"\"\"Find the font file in the directory structure\"\"\"\n",
    "        # Look in the main fonts directory\n",
    "        font_path = self.base_directory / \"fonts\" / filename\n",
    "        if font_path.exists():\n",
    "            return font_path\n",
    "            \n",
    "        # Look in dafonts-free-v1 directory\n",
    "        font_path = self.base_directory / \"dafonts-free-v1\" / filename\n",
    "        if font_path.exists():\n",
    "            return font_path\n",
    "            \n",
    "        return None\n",
    "\n",
    "    def render_font(self, font_info: Dict) -> Dict:\n",
    "        \"\"\"\n",
    "        Render a single font with all sample texts and sizes.\n",
    "        \n",
    "        Args:\n",
    "            font_info: Dictionary containing font information\n",
    "            \n",
    "        Returns:\n",
    "            Dictionary with rendering results and metadata\n",
    "        \"\"\"\n",
    "        filename = font_info['filename']\n",
    "        font_path = self._find_font_file(filename)\n",
    "        \n",
    "        if not font_path:\n",
    "            print(f\"Font file not found: {filename}\")\n",
    "            return {\n",
    "                'filename': filename,\n",
    "                'status': 'error',\n",
    "                'error': 'Font file not found'\n",
    "            }\n",
    "            \n",
    "        try:\n",
    "            results = []\n",
    "            \n",
    "            for font_size in self.font_sizes:\n",
    "                # Create a new image for this font size\n",
    "                image = Image.new('RGB', self.image_size, 'white')\n",
    "                draw = ImageDraw.Draw(image)\n",
    "                \n",
    "                try:\n",
    "                    font = ImageFont.truetype(str(font_path), font_size)\n",
    "                    # Use a smaller font for the info text\n",
    "                    info_font = ImageFont.truetype(str(font_path), max(font_size // 3, 24))\n",
    "                except Exception as e:\n",
    "                    print(f\"Error loading font {filename}: {e}\")\n",
    "                    continue\n",
    "                \n",
    "                # Calculate vertical spacing\n",
    "                y_offset = 10\n",
    "                max_height = self.image_size[1] - 60  # Reserve space for font info at bottom\n",
    "                \n",
    "                # Draw sample texts\n",
    "                for text in self.sample_texts:\n",
    "                    # Calculate text size\n",
    "                    text_bbox = draw.textbbox((0, 0), text, font=font)\n",
    "                    text_width = text_bbox[2] - text_bbox[0]\n",
    "                    text_height = text_bbox[3] - text_bbox[1]\n",
    "                    \n",
    "                    # Center text horizontally\n",
    "                    x = (self.image_size[0] - text_width) // 2\n",
    "                    \n",
    "                    # Draw text\n",
    "                    if y_offset + text_height < max_height:  # Ensure we don't overflow\n",
    "                        draw.text((x, y_offset), text, font=font, fill='black')\n",
    "                        y_offset += text_height + 10\n",
    "                \n",
    "                # Draw font information at bottom\n",
    "                info_text = f\"Font: {font_info['base_font_name']} ({font_size}px)\"\n",
    "                if 'creator' in font_info:\n",
    "                    info_text += f\" by {font_info['creator']}\"\n",
    "                \n",
    "                # Add category and theme if available\n",
    "                extra_info = []\n",
    "                if 'category' in font_info:\n",
    "                    extra_info.append(font_info['category'])\n",
    "                if 'theme' in font_info:\n",
    "                    extra_info.append(font_info['theme'])\n",
    "                \n",
    "                if extra_info:\n",
    "                    info_text += f\" • {' • '.join(extra_info)}\"\n",
    "                \n",
    "                # Calculate info text position\n",
    "                info_bbox = draw.textbbox((0, 0), info_text, font=info_font)\n",
    "                info_width = info_bbox[2] - info_bbox[0]\n",
    "                info_x = (self.image_size[0] - info_width) // 2\n",
    "                info_y = self.image_size[1] - 40\n",
    "                \n",
    "                # Draw semi-transparent background for info text\n",
    "                padding = 10\n",
    "                draw.rectangle(\n",
    "                    [\n",
    "                        info_x - padding,\n",
    "                        info_y - padding,\n",
    "                        info_x + info_width + padding,\n",
    "                        info_y + info_bbox[3] - info_bbox[1] + padding\n",
    "                    ],\n",
    "                    fill='white',\n",
    "                    outline='lightgray'\n",
    "                )\n",
    "                \n",
    "                # Draw info text\n",
    "                draw.text((info_x, info_y), info_text, font=info_font, fill='black')\n",
    "                \n",
    "                # Save the rendered image\n",
    "                output_filename = f\"{font_info['base_font_name']}_{font_size}px.png\"\n",
    "                output_filename = output_filename.replace(' ', '_').lower()\n",
    "                output_path = self.output_directory / output_filename\n",
    "                \n",
    "                image.save(output_path)\n",
    "                results.append({\n",
    "                    'size': font_size,\n",
    "                    'output_path': str(output_path)\n",
    "                })\n",
    "            \n",
    "            return {\n",
    "                'filename': filename,\n",
    "                'base_font_name': font_info['base_font_name'],\n",
    "                'category': font_info['category'],\n",
    "                'theme': font_info['theme'],\n",
    "                'status': 'success',\n",
    "                'rendered_images': results\n",
    "            }\n",
    "            \n",
    "        except Exception as e:\n",
    "            print(f\"Error rendering font {filename}: {e}\")\n",
    "            return {\n",
    "                'filename': filename,\n",
    "                'status': 'error',\n",
    "                'error': str(e)\n",
    "            }\n",
    "\n",
    "    def _get_output_filename(self, font_info: Dict, font_size: int) -> str:\n",
    "        \"\"\"Generate consistent output filename for a font\"\"\"\n",
    "        output_filename = f\"{font_info['base_font_name']}_{font_size}px.png\"\n",
    "        return output_filename.replace(' ', '_').lower()\n",
    "\n",
    "    def _is_font_already_rendered(self, font_info: Dict) -> bool:\n",
    "        \"\"\"\n",
    "        Check if all sizes of a font have already been rendered.\n",
    "        Returns True if all sizes exist, False if any size is missing.\n",
    "        \"\"\"\n",
    "        for font_size in self.font_sizes:\n",
    "            output_filename = self._get_output_filename(font_info, font_size)\n",
    "            output_path = self.output_directory / output_filename\n",
    "            if not output_path.exists():\n",
    "                return False\n",
    "        return True\n",
    "\n",
    "    def render_all_fonts(self, max_workers: int = 4, force_rerender: bool = False) -> List[Dict]:\n",
    "        \"\"\"\n",
    "        Render all fonts in parallel with progress tracking.\n",
    "        Skips already rendered fonts unless force_rerender is True.\n",
    "        \n",
    "        Args:\n",
    "            max_workers: Maximum number of concurrent workers\n",
    "            force_rerender: If True, rerenders all fonts even if they exist\n",
    "            \n",
    "        Returns:\n",
    "            List of dictionaries containing rendering results\n",
    "        \"\"\"\n",
    "        from tqdm.auto import tqdm\n",
    "        import time\n",
    "        \n",
    "        results = []\n",
    "        total_fonts = len(self.font_info)\n",
    "        processed = 0\n",
    "        errors = 0\n",
    "        skipped = 0\n",
    "        \n",
    "        # Filter fonts that need rendering\n",
    "        fonts_to_render = []\n",
    "        for _, font_info in self.font_info.iterrows():\n",
    "            if force_rerender or not self._is_font_already_rendered(font_info):\n",
    "                fonts_to_render.append(font_info)\n",
    "            else:\n",
    "                skipped += 1\n",
    "        \n",
    "        if not fonts_to_render:\n",
    "            print(\"All fonts are already rendered. Use force_rerender=True to rerender.\")\n",
    "            return []\n",
    "        \n",
    "        # Create progress bar\n",
    "        pbar = tqdm(\n",
    "            total=len(fonts_to_render), \n",
    "            desc=\"Rendering fonts\",\n",
    "            unit=\"font\",\n",
    "            bar_format=\"{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]\"\n",
    "        )\n",
    "        \n",
    "        # Initialize status counters\n",
    "        status_counts = {\"success\": 0, \"error\": 0}\n",
    "        \n",
    "        print(f\"\\nFound {len(fonts_to_render)} fonts to render (skipped {skipped} already rendered fonts)\")\n",
    "        \n",
    "        with ThreadPoolExecutor(max_workers=max_workers) as executor:\n",
    "            futures = {}\n",
    "            \n",
    "            # Submit all rendering jobs\n",
    "            for font_info in fonts_to_render:\n",
    "                future = executor.submit(self.render_font, font_info.to_dict())\n",
    "                futures[future] = font_info['filename']\n",
    "            \n",
    "            # Process completed futures as they finish\n",
    "            for future in futures:\n",
    "                try:\n",
    "                    result = future.result()\n",
    "                    if result:\n",
    "                        results.append(result)\n",
    "                        status_counts[result['status']] += 1\n",
    "                        \n",
    "                        # Update progress bar description with status\n",
    "                        pbar.set_postfix({\n",
    "                            \"success\": status_counts[\"success\"],\n",
    "                            \"errors\": status_counts[\"error\"],\n",
    "                            \"skipped\": skipped,\n",
    "                            \"current\": futures[future]\n",
    "                        }, refresh=True)\n",
    "                        \n",
    "                except Exception as e:\n",
    "                    print(f\"\\nError processing {futures[future]}: {str(e)}\")\n",
    "                    status_counts[\"error\"] += 1\n",
    "                \n",
    "                finally:\n",
    "                    pbar.update(1)\n",
    "        \n",
    "        pbar.close()\n",
    "        \n",
    "        # Print final summary\n",
    "        print(\"\\nRendering Summary:\")\n",
    "        print(f\"✓ Successfully rendered: {status_counts['success']} fonts\")\n",
    "        print(f\"✗ Failed to render: {status_counts['error']} fonts\")\n",
    "        print(f\"↷ Skipped (already rendered): {skipped} fonts\")\n",
    "        \n",
    "        # Load and include previously rendered fonts in the summary\n",
    "        if skipped > 0:\n",
    "            try:\n",
    "                old_summary_path = self.output_directory / \"rendering_summary.json\"\n",
    "                if old_summary_path.exists():\n",
    "                    with open(old_summary_path, 'r') as f:\n",
    "                        old_summary = json.load(f)\n",
    "                        if isinstance(old_summary, dict) and 'results' in old_summary:\n",
    "                            old_results = old_summary['results']\n",
    "                        else:\n",
    "                            old_results = old_summary\n",
    "                            \n",
    "                        # Add previously rendered fonts that weren't rerendered\n",
    "                        for old_result in old_results:\n",
    "                            if old_result['status'] == 'success':\n",
    "                                if not any(r['filename'] == old_result['filename'] for r in results):\n",
    "                                    results.append(old_result)\n",
    "            except Exception as e:\n",
    "                print(f\"Warning: Could not load previous summary: {e}\")\n",
    "        \n",
    "        # Save detailed summary\n",
    "        summary_path = self.output_directory / \"rendering_summary.json\"\n",
    "        summary = {\n",
    "            \"total_fonts\": total_fonts,\n",
    "            \"rendered_this_run\": len(fonts_to_render),\n",
    "            \"successful\": status_counts[\"success\"],\n",
    "            \"failed\": status_counts[\"error\"],\n",
    "            \"skipped\": skipped,\n",
    "            \"execution_time\": time.time() - pbar.start_t,\n",
    "            \"results\": results\n",
    "        }\n",
    "        \n",
    "        with open(summary_path, 'w') as f:\n",
    "            json.dump(summary, f, indent=2)\n",
    "        \n",
    "        print(f\"\\nDetailed summary saved to: {summary_path}\")\n",
    "        return results\n",
    "\n",
    "def render_fonts(base_dir: str, output_dir: str = \"rendered_fonts\") -> None:\n",
    "    \"\"\"\n",
    "    Convenience function to render all fonts in a directory.\n",
    "    \n",
    "    Args:\n",
    "        base_dir: Base directory containing fonts and info.csv\n",
    "        output_dir: Directory to save rendered images\n",
    "    \"\"\"\n",
    "    renderer = FontRenderer(\n",
    "        base_directory=base_dir,\n",
    "        output_directory=output_dir\n",
    "    )\n",
    "    \n",
    "    print(\"Starting font rendering...\")\n",
    "    results = renderer.render_all_fonts()\n",
    "    \n",
    "    # Print summary\n",
    "    successful = sum(1 for r in results if r['status'] == 'success')\n",
    "    failed = sum(1 for r in results if r['status'] == 'error')\n",
    "    \n",
    "    print(f\"\\nRendering complete!\")\n",
    "    print(f\"Successfully rendered: {successful} fonts\")\n",
    "    print(f\"Failed to render: {failed} fonts\")\n",
    "    print(f\"Results saved to: {output_dir}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# render_fonts(\n",
    "#     base_dir=\"C:\\sandbox\\generative-typography\\dafonts-free-v1\\dafonts-free-v1\",\n",
    "#     output_dir=\"rendered_fonts\"\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "desc_prompt = \"\"\"\n",
    "Balanced Font Analysis Prompt\n",
    "\n",
    "You are a font design expert who understands both classical typography and contemporary digital culture. Your task is to analyze fonts comprehensively, balancing technical expertise with cultural understanding and intuitive interpretations.\n",
    "\n",
    "Analysis Framework\n",
    "\n",
    "Examine the font through these balanced perspectives:\n",
    "\n",
    "TECHNICAL FOUNDATION\n",
    "\n",
    "Construction and anatomy\n",
    "\n",
    "Proportions and relationships\n",
    "\n",
    "Distinctive features and characteristics\n",
    "\n",
    "Quality of execution\n",
    "\n",
    "DESIGN PERSONALITY\n",
    "\n",
    "Overall character and mood\n",
    "\n",
    "Historical influences\n",
    "\n",
    "Contemporary relevance\n",
    "\n",
    "Cultural associations\n",
    "\n",
    "PRACTICAL CONTEXT\n",
    "\n",
    "Intended applications\n",
    "\n",
    "Effective use cases\n",
    "\n",
    "Technical limitations\n",
    "\n",
    "Performance characteristics\n",
    "\n",
    "INTUITIVE INTERPRETATION\n",
    "\n",
    "Emotional response\n",
    "\n",
    "Cultural resonance\n",
    "\n",
    "Abstract associations\n",
    "\n",
    "Contemporary context\n",
    "\n",
    "{\n",
    "    \"detailed_description\": [\n",
    "        // MANDATORY: 10+ sentences combining:\n",
    "        // - Technical analysis (40%)\n",
    "        // - Design character (30%)\n",
    "        // - Practical observations (20%)\n",
    "        // - Cultural/abstract interpretation (10%)\n",
    "        // Focus on specific features that create the font's character\n",
    "        // Include both objective analysis and thoughtful interpretation\n",
    "    ],\n",
    "    \n",
    "    \"technical_characteristics\": [\n",
    "        // 5-7 key technical features\n",
    "        // e.g., \"high x-height\", \"geometric construction\", \"sharp terminals\"\n",
    "        // Focus on distinctive elements\n",
    "    ],\n",
    "    \n",
    "    \"personality_traits\": [\n",
    "        // 5-7 character descriptions\n",
    "        // Mix of design-focused and interpretive terms\n",
    "        // e.g., \"confidently geometric\", \"carefully balanced\", \"subtly playful\"\n",
    "        // Include both professional and accessible language\n",
    "    ],\n",
    "    \n",
    "    \"practical_contexts\": [\n",
    "        // 3-5 primary use cases\n",
    "        // Consider both traditional and digital applications\n",
    "        // Include specific size ranges or media if relevant\n",
    "    ],\n",
    "    \n",
    "    \"cultural_intuition\": [\n",
    "        // 3-5 cultural or abstract associations\n",
    "        // Keep it grounded but insightful\n",
    "        // e.g., \"evokes mid-century optimism\", \"suggests digital-native design\"\n",
    "        // Balance historical and contemporary references\n",
    "    ],\n",
    "    \n",
    "    \"search_keywords\": [\n",
    "        // 10-15 balanced key terms\n",
    "        // 60% technical/practical\n",
    "        // 40% interpretive/cultural\n",
    "        // Include terms at different levels of expertise\n",
    "    ]\n",
    "}\n",
    "content_copy\n",
    " Use code with caution.\n",
    "Json\n",
    "Key Guidelines:\n",
    "\n",
    "MAINTAIN BALANCE\n",
    "\n",
    "Lead with technical observation\n",
    "\n",
    "Support with design interpretation\n",
    "\n",
    "Season with cultural understanding\n",
    "\n",
    "Finish with practical insight\n",
    "\n",
    "BE SPECIFIC\n",
    "\n",
    "Reference actual features\n",
    "\n",
    "Connect features to impressions\n",
    "\n",
    "Explain technical terms\n",
    "\n",
    "Ground abstract observations\n",
    "\n",
    "CONSIDER CONTEXT\n",
    "\n",
    "Historical perspective\n",
    "\n",
    "Contemporary usage\n",
    "\n",
    "Digital application\n",
    "\n",
    "Cultural placement\n",
    "\n",
    "CONNECT QUALITIES\n",
    "\n",
    "Link technical features to personality\n",
    "\n",
    "Connect design choices to effects\n",
    "\n",
    "Relate characteristics to applications\n",
    "\n",
    "Ground abstract observations in specific features\n",
    "\n",
    "Remember: Your analysis should be equally valuable to a type designer examining letterforms and a designer seeking the right personality for a project.\n",
    "\n",
    "Example Balance:\n",
    "\n",
    "\"The font combines geometric construction principles with subtly humanist details. Its high x-height and open counters ensure strong legibility, while the slightly rounded terminals add a touch of approachability. This balance makes it equally suitable for corporate communications and modern digital interfaces, evoking professionalism without feeling sterile.\"\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from pathlib import Path\n",
    "import json\n",
    "from typing import Dict, List\n",
    "import google.generativeai as genai\n",
    "from google.ai.generativelanguage_v1beta.types import content\n",
    "from tqdm.auto import tqdm\n",
    "import time\n",
    "import logging\n",
    "from PIL import Image\n",
    "import base64\n",
    "from datetime import datetime, timedelta\n",
    "from collections import deque\n",
    "\n",
    "# Set up logging\n",
    "logging.basicConfig(level=logging.INFO)\n",
    "logger = logging.getLogger(__name__)\n",
    "\n",
    "class RateLimiter:\n",
    "    def __init__(self, calls_per_minute: int):\n",
    "        \"\"\"Initialize rate limiter with calls per minute limit\"\"\"\n",
    "        self.calls_per_minute = calls_per_minute\n",
    "        self.window_size = 60  # seconds\n",
    "        self.calls = deque()\n",
    "\n",
    "    def wait_if_needed(self):\n",
    "        \"\"\"Wait if we've exceeded our rate limit\"\"\"\n",
    "        now = datetime.now()\n",
    "        \n",
    "        # Remove calls older than our window\n",
    "        while self.calls and (now - self.calls[0]).total_seconds() > self.window_size:\n",
    "            self.calls.popleft()\n",
    "        \n",
    "        # If we're at our limit, wait until we can make another call\n",
    "        if len(self.calls) >= self.calls_per_minute:\n",
    "            wait_time = (self.calls[0] + timedelta(seconds=self.window_size) - now).total_seconds()\n",
    "            if wait_time > 0:\n",
    "                logger.info(f\"Rate limit reached. Waiting {wait_time:.2f} seconds...\")\n",
    "                time.sleep(wait_time)\n",
    "        \n",
    "        # Record this call\n",
    "        self.calls.append(now)\n",
    "\n",
    "class FontDescriptionGenerator:\n",
    "    def __init__(self,\n",
    "                 rendered_dir: str,\n",
    "                 output_dir: str = \"font_descriptions\",\n",
    "                 gemini_api_key: str = None,\n",
    "                 calls_per_minute: int = 60):  # Added rate limit parameter\n",
    "        \"\"\"Initialize the font description generator\"\"\"\n",
    "        self.rendered_dir = Path(rendered_dir)\n",
    "        self.output_dir = Path(output_dir)\n",
    "        self.output_dir.mkdir(parents=True, exist_ok=True)\n",
    "        self.rate_limiter = RateLimiter(calls_per_minute)  # Initialize rate limiter\n",
    "        \n",
    "        if gemini_api_key:\n",
    "            self._init_gemini(gemini_api_key)\n",
    "\n",
    "    def _init_gemini(self, api_key: str):\n",
    "        \"\"\"Initialize Gemini with safe configuration\"\"\"\n",
    "        try:\n",
    "            genai.configure(api_key=api_key)\n",
    "            \n",
    "            generation_config = {\n",
    "                \"temperature\": 0.4,\n",
    "                \"top_p\": 0,\n",
    "                \"top_k\": 40,\n",
    "                \"max_output_tokens\": 8192,\n",
    "                \"response_mime_type\": \"application/json\",\n",
    "            }\n",
    "            \n",
    "            self.model = genai.GenerativeModel(\n",
    "                model_name=\"gemini-1.5-flash\",\n",
    "                generation_config=generation_config\n",
    "            )\n",
    "        except Exception as e:\n",
    "            logger.error(f\"Failed to initialize Gemini: {e}\")\n",
    "            raise\n",
    "\n",
    "    def generate_single_description(self, image_path: Path) -> Dict:\n",
    "        \"\"\"Generate description for a single image with robust error handling\"\"\"\n",
    "        description_path = self.output_dir / f\"{image_path.stem}.json\"\n",
    "        \n",
    "        # Check for existing description\n",
    "        if description_path.exists():\n",
    "            logger.info(f\"Using existing description for {image_path.name}\")\n",
    "            try:\n",
    "                with open(description_path) as f:\n",
    "                    return json.load(f)\n",
    "            except json.JSONDecodeError:\n",
    "                logger.warning(f\"Corrupted description file for {image_path.name}, regenerating\")\n",
    "        \n",
    "        try:\n",
    "            # Load and validate image\n",
    "            try:\n",
    "                img = Image.open(image_path)\n",
    "                img.verify()  # Verify image integrity\n",
    "            except Exception as e:\n",
    "                logger.error(f\"Invalid image file {image_path}: {e}\")\n",
    "                return {\n",
    "                    'filename': image_path.name,\n",
    "                    'status': 'error',\n",
    "                    'error': f'Invalid image file: {str(e)}'\n",
    "                }\n",
    "\n",
    "            # Prepare prompt\n",
    "            prompt = desc_prompt\n",
    "\n",
    "            # Apply rate limiting before making API call\n",
    "            # self.rate_limiter.wait_if_needed()\n",
    "\n",
    "            # Get response from Gemini\n",
    "            response = self.model.generate_content(\n",
    "                [prompt, Image.open(image_path)],\n",
    "                stream=False\n",
    "            )\n",
    "\n",
    "            # Extract and parse JSON from response\n",
    "            try:\n",
    "                text = response.text\n",
    "                \n",
    "                if '```json' in text:\n",
    "                    text = text.split('```json')[1].split('```')[0]\n",
    "                elif '```' in text:\n",
    "                    text = text.split('```')[1].split('```')[0]\n",
    "                    \n",
    "                description = json.loads(text.strip())\n",
    "                \n",
    "                result = {\n",
    "                    'filename': image_path.name,\n",
    "                    'status': 'success',\n",
    "                    'description': description\n",
    "                }\n",
    "            except json.JSONDecodeError as e:\n",
    "                logger.error(f\"Failed to parse JSON for {image_path.name}: {e}\")\n",
    "                result = {\n",
    "                    'filename': image_path.name,\n",
    "                    'status': 'error',\n",
    "                    'error': 'Failed to parse JSON response',\n",
    "                    'raw_response': response.text\n",
    "                }\n",
    "\n",
    "            # Save result\n",
    "            with open(description_path, 'w') as f:\n",
    "                json.dump(result, f, indent=2)\n",
    "\n",
    "            return result\n",
    "\n",
    "        except Exception as e:\n",
    "            error_msg = f\"Error processing {image_path.name}: {str(e)}\"\n",
    "            logger.error(error_msg)\n",
    "            return {\n",
    "                'filename': image_path.name,\n",
    "                'status': 'error',\n",
    "                'error': error_msg\n",
    "            }\n",
    "\n",
    "    def generate_descriptions(self, max_retries: int = 3, delay: int = 5) -> List[Dict]:\n",
    "        \"\"\"Generate descriptions for all images with retry logic\"\"\"\n",
    "        image_paths = list(self.rendered_dir.glob(\"*.png\"))\n",
    "        if not image_paths:\n",
    "            logger.warning(f\"No PNG images found in {self.rendered_dir}\")\n",
    "            return []\n",
    "        \n",
    "        # create a filter to process only the images with {font_name}_36px.png\n",
    "        image_paths = [image for image in image_paths if image.stem.endswith(\"_36px\")]\n",
    "\n",
    "        results = []\n",
    "        skipped = 0\n",
    "        \n",
    "        # Create progress bar\n",
    "        pbar = tqdm(total=len(image_paths), desc=\"Generating descriptions\")\n",
    "        \n",
    "        for image_path in image_paths:\n",
    "            description_path = self.output_dir / f\"{image_path.stem}.json\"\n",
    "            \n",
    "            # Skip if exists and valid\n",
    "            if description_path.exists():\n",
    "                try:\n",
    "                    with open(description_path) as f:\n",
    "                        json.load(f)  # Verify JSON is valid\n",
    "                    skipped += 1\n",
    "                    pbar.update(1)\n",
    "                    continue\n",
    "                except (json.JSONDecodeError, Exception):\n",
    "                    pass  # Will regenerate if JSON is invalid\n",
    "            \n",
    "            # Try with retries\n",
    "            for attempt in range(max_retries):\n",
    "                try:\n",
    "                    result = self.generate_single_description(image_path)\n",
    "                    results.append(result)\n",
    "                    break\n",
    "                except Exception as e:\n",
    "                    if attempt == max_retries - 1:\n",
    "                        logger.error(f\"Failed all retries for {image_path.name}: {e}\")\n",
    "                        results.append({\n",
    "                            'filename': image_path.name,\n",
    "                            'status': 'error',\n",
    "                            'error': f'Failed after {max_retries} attempts: {str(e)}'\n",
    "                        })\n",
    "                    else:\n",
    "                        logger.warning(f\"Attempt {attempt + 1} failed for {image_path.name}, retrying...\")\n",
    "                        time.sleep(delay)\n",
    "            \n",
    "            pbar.update(1)\n",
    "        \n",
    "        pbar.close()\n",
    "\n",
    "        # Generate summary\n",
    "        successful = sum(1 for r in results if r['status'] == 'success')\n",
    "        failed = sum(1 for r in results if r['status'] == 'error')\n",
    "        \n",
    "        logger.info(\"\\nGeneration Summary:\")\n",
    "        logger.info(f\"✓ Successfully generated: {successful} descriptions\")\n",
    "        logger.info(f\"✗ Failed to generate: {failed} descriptions\")\n",
    "        logger.info(f\"↷ Skipped (existing): {skipped} descriptions\")\n",
    "\n",
    "        # Save summary\n",
    "        summary = {\n",
    "            \"total_images\": len(image_paths),\n",
    "            \"successful\": successful,\n",
    "            \"failed\": failed,\n",
    "            \"skipped\": skipped,\n",
    "            \"results\": results\n",
    "        }\n",
    "        \n",
    "        with open(self.output_dir / \"generation_summary.json\", 'w') as f:\n",
    "            json.dump(summary, f, indent=2)\n",
    "\n",
    "        return results\n",
    "\n",
    "def generate_descriptions(rendered_dir: str, \n",
    "                        output_dir: str = \"font_descriptions\",\n",
    "                        gemini_api_key: str = None,\n",
    "                        calls_per_minute: int = 60) -> None:  # Added rate limit parameter\n",
    "    \"\"\"Convenience function to generate descriptions\"\"\"\n",
    "    generator = FontDescriptionGenerator(\n",
    "        rendered_dir=rendered_dir,\n",
    "        output_dir=output_dir,\n",
    "        gemini_api_key=gemini_api_key,\n",
    "        calls_per_minute=calls_per_minute  # Pass rate limit to generator\n",
    "    )\n",
    "    \n",
    "    logger.info(\"Starting description generation...\")\n",
    "    results = generator.generate_descriptions()\n",
    "    logger.info(\"Description generation complete!\")\n",
    "    with open('results.json', 'w') as f:\n",
    "        json.dump(results, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:__main__:Starting description generation...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c2aa446150e04221b2b7cf9bc6c5771a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generating descriptions:   0%|          | 0/12510 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:__main__:Invalid image file rendered_fonts\\aar_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\airment_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\aka_acid_gr_chubby_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\album_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\alegant_script_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\aranea_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\army_watch_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\astron_boy_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ato_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\a_ai_love_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\a_another_tag_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\bad_handwriting_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\beauty_angelique_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\binjay_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\biting_my_nails_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\boldie_script_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\bonzer_-_bruxelles_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\cartoonic_massive_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\chameleon_dreams_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\citaro_voor_(dubbele_hoogte_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\cliche_21_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\coaster_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\code_new_roman_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\complete_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\csar_parade_dress_display_caps_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dalmata_dream_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\danoise_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dearest_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dearest_friend_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dolce_vita_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dowry_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\drakoheart_leiend_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dream_orphans_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\dumbbell_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\e1234_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\east_anglia_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\effloresce_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\elevant_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\eleventh_square_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ember_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\epic_fusion_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\eppy_evans_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\euphoric_brk_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\european_monogram_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\excluded_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fake_serif_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fanatika_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ferda_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fette_bauersche_antiqua_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fibel_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\filament_serie_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\firty_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fixed_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\flow_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fontastique_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fontgrab_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\forgotten_futurist_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fortheenas_01_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\forturn_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\fortzilla_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\freezone_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gaelle_number_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ganz_grobe_gotisch_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gentium_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ghiya_strokes_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ghostmeat_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gibson_walsh_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gigabyte_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gipsiero_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gravity_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\grids_n_things_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\grid_concrete_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gross_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\guest_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Error processing guns_2_36px.png: The `response.text` quick accessor only works when the response contains a valid `Part`, but none was returned. Check the `candidate.safety_ratings` to see if the response was blocked.\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\gwara_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\handgoal_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\hasteristico_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\hattori_hanzo_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\heraldry_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\herkules_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\horbse_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\horse_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\hvd_spencils_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\iglesia_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\impossibilium_brk_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\informal_style_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\jd_carnival_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\jd_fantasy_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Error processing jofont_36px.png: 504 Deadline Exceeded\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\johanna_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\karisma_stencil_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\kenta_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\ketosag_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\key_virtue_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\kick_haters_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Failed to parse JSON for kiebitz_36px.png: Unterminated string starting at: line 1 column 26 (char 25)\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\killigrew_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\kingthings_petrock_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Error processing kisstell_36px.png: The `response.text` quick accessor only works when the response contains a valid `Part`, but none was returned. Check the `candidate.safety_ratings` to see if the response was blocked.\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\klein_slabserif_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\latina_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\liberation_mono_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\liquid_crystal_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\lt_emphasis_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\lt_internet_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Error processing made_in_spain_2_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNAVAILABLE: ipv4:142.250.72.170:443: No route to host\n",
      "ERROR:__main__:Error processing made_in_spain_3_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:142.250.176.10:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing made_in_spain_4_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:142.251.40.42:443: socket is null\n",
      "ERROR:__main__:Error processing made_in_spain_5_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:142.250.176.10:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Invalid image file rendered_fonts\\made_likes_slab_36px.png: broken PNG file (bad header checksum in b'IDAT')\n",
      "ERROR:__main__:Error processing madfont_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing madison_square_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing madman_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing maduo_etra_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing madura_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing mad_pixels_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.14.106:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing mae3_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:142.250.189.10:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing maelstrom_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:142.250.189.10:443: tcp handshaker shutdown\n",
      "ERROR:__main__:Error processing mael_36px.png: Deadline of 60.0s exceeded while calling target function, last exception: 503 failed to connect to all addresses; last error: UNKNOWN: ipv4:172.217.12.138:443: tcp handshaker shutdown\n"
     ]
    }
   ],
   "source": [
    "api_key = \"\"\n",
    "if not api_key:\n",
    "    raise ValueError(\"Please set the GEMINI_API_KEY environment variable\")\n",
    "    \n",
    "generate_descriptions(\n",
    "    rendered_dir=\"rendered_fonts\",\n",
    "    output_dir=\"font_descriptions\",\n",
    "    gemini_api_key=api_key,\n",
    "    calls_per_minute=2000\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}