update

Paper2Poster/PosterAgent/__init__.py

@@ -1,16 +1,16 @@
 from . import (
-    apply_theme,
-    create_dataset,
-    deoverflow,
-    deoverflow_parallel,
-    fill_and_style,
-    gen_outline_layout_parallel,
+    # apply_theme,
+    # create_dataset,
+    # deoverflow,
+    # deoverflow_parallel,
+    # fill_and_style,
+    # gen_outline_layout_parallel,
     gen_outline_layout,
-    gen_poster_content,
-    gen_pptx_code,
-    LLM_direct_generate,
-    new_pipeline,
+    # gen_poster_content,
+    # gen_pptx_code,
+    # LLM_direct_generate,
+    # new_pipeline,
     parse_raw,
-    poster_gen_pipeline,
+    # poster_gen_pipeline,
     tree_split_layout
 )

Paper2Poster/PosterAgent/gen_outline_layout.py

@@ -3,15 +3,16 @@ import os
 import json
 import copy
 import yaml
+import json_repair
 from jinja2 import Environment, StrictUndefined
 
-from utils.src.utils import ppt_to_images, get_json_from_response
+# from utils.src.utils import ppt_to_images, get_json_from_response
 
 from camel.models import ModelFactory
 from camel.agents import ChatAgent
 from camel.messages import BaseMessage
 
-from utils.pptx_utils import *
+# from utils.pptx_utils import *
 from utils.wei_utils import *
 
 import pickle as pkl
@@ -24,6 +25,23 @@ IMAGE_SCALE_RATIO_MAX = 40
 TABLE_SCALE_RATIO_MIN = 100
 TABLE_SCALE_RATIO_MAX = 80
 
+def get_json_from_response(raw_response: str):
+    response = raw_response.strip()
+    l, r = response.rfind("```json"), response.rfind("```")
+    try:
+        if l == -1 or r == -1:
+            response = json_repair.loads(response)
+        else:
+            response = json_repair.loads(response[l + 7 : r].strip())
+        return response
+    except Exception as e:
+        raise RuntimeError("Failed to parse JSON from response", e)
+    
+def account_token(response):
+    input_token = response.info['usage']['prompt_tokens']
+    output_token = response.info['usage']['completion_tokens']
+
+    return input_token, output_token
 def compute_tp(raw_content_json):
     total_length = 0
     for section in raw_content_json['sections']:
@@ -426,408 +444,408 @@ def gen_outline_layout_v2(args, actor_config):
 
     return total_input_token, total_output_token, paper_panels, figure_arrangement
 
-def gen_outline_layout(args, actor_config, critic_config):
-    poster_log_path = f'log/{args.model_name}_{args.poster_name}_poster_{args.index}'
-    if not os.path.exists(poster_log_path):
-        os.mkdir(poster_log_path)
-    total_input_token, total_output_token = 0, 0
-    consumption_log = {
-        'outline': [],
-        'h1_actor': [],
-        'h2_actor': [],
-        'h1_critic': [],
-        'gen_layout': []
-    }
-    jinja_env = Environment(undefined=StrictUndefined)
-    outline_file_path = f'outlines/{args.model_name}_{args.poster_name}_outline_{args.index}.json'
-    agent_name = 'poster_planner_new'
-    agent_init_name = 'layout_agent_init'
-    agent_new_section_name = 'layout_agent_new_section'
-    h1_critic_name = 'critic_layout_hierarchy_1'
-    h2_actor_name = 'actor_layout_hierarchy_2'
-
-    doc_json = json.load(open(f'contents/{args.model_name}_{args.poster_name}_raw_content.json', 'r'))
-    filtered_table_information = json.load(open(f'images_and_tables/{args.poster_name}_tables_filtered.json', 'r'))
-    filtered_image_information = json.load(open(f'images_and_tables/{args.poster_name}_images_filtered.json', 'r'))
-
-    with open(f"utils/prompt_templates/{agent_name}.yaml", "r", encoding="utf-8") as f:
-        planner_config = yaml.safe_load(f)
-
-    with open(f"utils/prompt_templates/{agent_init_name}.yaml", "r", encoding="utf-8") as f:
-        config_init = yaml.safe_load(f)
-
-    with open(f"utils/prompt_templates/{agent_new_section_name}.yaml", "r", encoding="utf-8") as f:
-        config_new_section = yaml.safe_load(f)
-
-    with open(f"utils/prompt_templates/{h1_critic_name}.yaml", "r", encoding="utf-8") as f:
-        config_h1_critic = yaml.safe_load(f)
-
-    with open(f"utils/prompt_templates/{h2_actor_name}.yaml", "r", encoding="utf-8") as f:
-        config_h2_actor = yaml.safe_load(f)
-
-    planner_model = ModelFactory.create(
-        model_platform=actor_config['model_platform'],
-        model_type=actor_config['model_type'],
-        model_config_dict=actor_config['model_config'],
-    )
-
-    planner_agent = ChatAgent(
-        system_message=planner_config['system_prompt'],
-        model=planner_model,
-        message_window_size=10,
-    )
-
-    outline_template = jinja_env.from_string(planner_config["template"])
-
-    planner_jinja_args = {
-        'json_content': doc_json,
-        'table_information': filtered_table_information,
-        'image_information': filtered_image_information,
-    }
-
-    actor_model = ModelFactory.create(
-        model_platform=actor_config['model_platform'],
-        model_type=actor_config['model_type'],
-        model_config_dict=actor_config['model_config'],
-    )
-
-    init_actor_sys_msg = config_init['system_prompt']
-
-    init_actor_agent = ChatAgent(
-        system_message=init_actor_sys_msg,
-        model=actor_model,
-        message_window_size=10,
-    )
-
-    new_section_actor_sys_msg = config_new_section['system_prompt']
-    new_section_actor_agent = ChatAgent(
-        system_message=new_section_actor_sys_msg,
-        model=actor_model,
-        message_window_size=10,
-    )
-
-    h1_critic_model = ModelFactory.create(
-        model_platform=critic_config['model_platform'],
-        model_type=critic_config['model_type'],
-        model_config_dict=critic_config['model_config'],
-    )
-
-    h1_critic_sys_msg = config_h1_critic['system_prompt']
-
-    h1_critic_agent = ChatAgent(
-        system_message=h1_critic_sys_msg,
-        model=h1_critic_model,
-        message_window_size=None,
-    )
-
-    h1_pos_example = Image.open('assets/h1_example/h1_pos.jpg')
-    h1_neg_example = Image.open('assets/h1_example/h1_neg.jpg')
-
-    h2_actor_model = ModelFactory.create(
-        model_platform=actor_config['model_platform'],
-        model_type=actor_config['model_type'],
-        model_config_dict=actor_config['model_config'],
-    )
-
-    h2_actor_sys_msg = config_h2_actor['system_prompt']
-
-    h2_actor_agent = ChatAgent(
-        system_message=h2_actor_sys_msg,
-        model=h2_actor_model,
-        message_window_size=10,
-    )
-
-    attempt = 0
-    while True:
-        print(f'Generating outline attempt {attempt}...')
-        planner_prompt = outline_template.render(**planner_jinja_args)
-        planner_agent.reset()
-        response = planner_agent.step(planner_prompt)
-        input_token, output_token = account_token(response)
-        consumption_log['outline'].append((input_token, output_token))
-        total_input_token += input_token
-        total_output_token += output_token
-
-        outline = get_json_from_response(response.msgs[0].content)
-        name_to_hierarchy = get_hierarchy(outline)
-
-        sections = list(outline.keys())
-        sections = [x for x in sections if x != 'meta']
-        init_template = jinja_env.from_string(config_init["template"])
-        new_section_template = jinja_env.from_string(config_new_section["template"])
-        h1_critic_template = jinja_env.from_string(config_h1_critic["template"])
-        init_outline = {'meta': outline['meta'], sections[0]: outline[sections[0]]}
-
-        new_outline = outline
-
-        init_jinja_args = {
-            'json_outline': init_outline,
-            'function_docs': documentation
-        }
-
-        init_prompt = init_template.render(**init_jinja_args)
-
-        # hierarchy 1 only
-        outline_location = get_outline_location(outline, subsection=False)
-        logs = {}
-        curr_section = sections[0]
-
-        layout_cumulative_input_token = 0
-        layout_cumulative_output_token = 0
-
-        print('Generating h1 layout...\n')
-        print(f'Generating h1 layout for section {curr_section}...')
-        logs[curr_section] = gen_layout(
-            init_actor_agent, 
-            init_prompt, 
-            args.max_retry, 
-            name_to_hierarchy, 
-            visual_identifier=curr_section
-        )
-
-        if logs[curr_section][-1]['error'] is not None:
-            raise ValueError(f'Failed to generate layout for section {curr_section}.')
+# def gen_outline_layout(args, actor_config, critic_config):
+#     poster_log_path = f'log/{args.model_name}_{args.poster_name}_poster_{args.index}'
+#     if not os.path.exists(poster_log_path):
+#         os.mkdir(poster_log_path)
+#     total_input_token, total_output_token = 0, 0
+#     consumption_log = {
+#         'outline': [],
+#         'h1_actor': [],
+#         'h2_actor': [],
+#         'h1_critic': [],
+#         'gen_layout': []
+#     }
+#     jinja_env = Environment(undefined=StrictUndefined)
+#     outline_file_path = f'outlines/{args.model_name}_{args.poster_name}_outline_{args.index}.json'
+#     agent_name = 'poster_planner_new'
+#     agent_init_name = 'layout_agent_init'
+#     agent_new_section_name = 'layout_agent_new_section'
+#     h1_critic_name = 'critic_layout_hierarchy_1'
+#     h2_actor_name = 'actor_layout_hierarchy_2'
+
+#     doc_json = json.load(open(f'contents/{args.model_name}_{args.poster_name}_raw_content.json', 'r'))
+#     filtered_table_information = json.load(open(f'images_and_tables/{args.poster_name}_tables_filtered.json', 'r'))
+#     filtered_image_information = json.load(open(f'images_and_tables/{args.poster_name}_images_filtered.json', 'r'))
+
+#     with open(f"utils/prompt_templates/{agent_name}.yaml", "r", encoding="utf-8") as f:
+#         planner_config = yaml.safe_load(f)
+
+#     with open(f"utils/prompt_templates/{agent_init_name}.yaml", "r", encoding="utf-8") as f:
+#         config_init = yaml.safe_load(f)
+
+#     with open(f"utils/prompt_templates/{agent_new_section_name}.yaml", "r", encoding="utf-8") as f:
+#         config_new_section = yaml.safe_load(f)
+
+#     with open(f"utils/prompt_templates/{h1_critic_name}.yaml", "r", encoding="utf-8") as f:
+#         config_h1_critic = yaml.safe_load(f)
+
+#     with open(f"utils/prompt_templates/{h2_actor_name}.yaml", "r", encoding="utf-8") as f:
+#         config_h2_actor = yaml.safe_load(f)
+
+#     planner_model = ModelFactory.create(
+#         model_platform=actor_config['model_platform'],
+#         model_type=actor_config['model_type'],
+#         model_config_dict=actor_config['model_config'],
+#     )
+
+#     planner_agent = ChatAgent(
+#         system_message=planner_config['system_prompt'],
+#         model=planner_model,
+#         message_window_size=10,
+#     )
+
+#     outline_template = jinja_env.from_string(planner_config["template"])
+
+#     planner_jinja_args = {
+#         'json_content': doc_json,
+#         'table_information': filtered_table_information,
+#         'image_information': filtered_image_information,
+#     }
+
+#     actor_model = ModelFactory.create(
+#         model_platform=actor_config['model_platform'],
+#         model_type=actor_config['model_type'],
+#         model_config_dict=actor_config['model_config'],
+#     )
+
+#     init_actor_sys_msg = config_init['system_prompt']
+
+#     init_actor_agent = ChatAgent(
+#         system_message=init_actor_sys_msg,
+#         model=actor_model,
+#         message_window_size=10,
+#     )
+
+#     new_section_actor_sys_msg = config_new_section['system_prompt']
+#     new_section_actor_agent = ChatAgent(
+#         system_message=new_section_actor_sys_msg,
+#         model=actor_model,
+#         message_window_size=10,
+#     )
+
+#     h1_critic_model = ModelFactory.create(
+#         model_platform=critic_config['model_platform'],
+#         model_type=critic_config['model_type'],
+#         model_config_dict=critic_config['model_config'],
+#     )
+
+#     h1_critic_sys_msg = config_h1_critic['system_prompt']
+
+#     h1_critic_agent = ChatAgent(
+#         system_message=h1_critic_sys_msg,
+#         model=h1_critic_model,
+#         message_window_size=None,
+#     )
+
+#     h1_pos_example = Image.open('assets/h1_example/h1_pos.jpg')
+#     h1_neg_example = Image.open('assets/h1_example/h1_neg.jpg')
+
+#     h2_actor_model = ModelFactory.create(
+#         model_platform=actor_config['model_platform'],
+#         model_type=actor_config['model_type'],
+#         model_config_dict=actor_config['model_config'],
+#     )
+
+#     h2_actor_sys_msg = config_h2_actor['system_prompt']
+
+#     h2_actor_agent = ChatAgent(
+#         system_message=h2_actor_sys_msg,
+#         model=h2_actor_model,
+#         message_window_size=10,
+#     )
+
+#     attempt = 0
+#     while True:
+#         print(f'Generating outline attempt {attempt}...')
+#         planner_prompt = outline_template.render(**planner_jinja_args)
+#         planner_agent.reset()
+#         response = planner_agent.step(planner_prompt)
+#         input_token, output_token = account_token(response)
+#         consumption_log['outline'].append((input_token, output_token))
+#         total_input_token += input_token
+#         total_output_token += output_token
+
+#         outline = get_json_from_response(response.msgs[0].content)
+#         name_to_hierarchy = get_hierarchy(outline)
+
+#         sections = list(outline.keys())
+#         sections = [x for x in sections if x != 'meta']
+#         init_template = jinja_env.from_string(config_init["template"])
+#         new_section_template = jinja_env.from_string(config_new_section["template"])
+#         h1_critic_template = jinja_env.from_string(config_h1_critic["template"])
+#         init_outline = {'meta': outline['meta'], sections[0]: outline[sections[0]]}
+
+#         new_outline = outline
+
+#         init_jinja_args = {
+#             'json_outline': init_outline,
+#             'function_docs': documentation
+#         }
+
+#         init_prompt = init_template.render(**init_jinja_args)
+
+#         # hierarchy 1 only
+#         outline_location = get_outline_location(outline, subsection=False)
+#         logs = {}
+#         curr_section = sections[0]
+
+#         layout_cumulative_input_token = 0
+#         layout_cumulative_output_token = 0
+
+#         print('Generating h1 layout...\n')
+#         print(f'Generating h1 layout for section {curr_section}...')
+#         logs[curr_section] = gen_layout(
+#             init_actor_agent, 
+#             init_prompt, 
+#             args.max_retry, 
+#             name_to_hierarchy, 
+#             visual_identifier=curr_section
+#         )
+
+#         if logs[curr_section][-1]['error'] is not None:
+#             raise ValueError(f'Failed to generate layout for section {curr_section}.')
         
-        layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
-        layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
-
-        for section_index in range(1, len(sections)):
-            curr_section = sections[section_index]
-            print(f'generating h1 layout for section {curr_section}...')
-            new_section_outline = {curr_section: new_outline[curr_section]}
-            new_section_jinja_args = {
-                'json_outline': new_section_outline,
-                'function_docs': documentation
-            }
-            new_section_prompt = new_section_template.render(**new_section_jinja_args)
-
-            logs[curr_section] = gen_layout(
-                new_section_actor_agent, 
-                new_section_prompt, 
-                args.max_retry, 
-                name_to_hierarchy, 
-                visual_identifier=curr_section,
-                existing_code = logs[sections[section_index - 1]][-1]['concatenated_code']
-            )
-            if logs[curr_section][-1]['error'] is not None:
-                raise ValueError(f'Failed to generate layout for section {curr_section}.')
+#         layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
+#         layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
+
+#         for section_index in range(1, len(sections)):
+#             curr_section = sections[section_index]
+#             print(f'generating h1 layout for section {curr_section}...')
+#             new_section_outline = {curr_section: new_outline[curr_section]}
+#             new_section_jinja_args = {
+#                 'json_outline': new_section_outline,
+#                 'function_docs': documentation
+#             }
+#             new_section_prompt = new_section_template.render(**new_section_jinja_args)
+
+#             logs[curr_section] = gen_layout(
+#                 new_section_actor_agent, 
+#                 new_section_prompt, 
+#                 args.max_retry, 
+#                 name_to_hierarchy, 
+#                 visual_identifier=curr_section,
+#                 existing_code = logs[sections[section_index - 1]][-1]['concatenated_code']
+#             )
+#             if logs[curr_section][-1]['error'] is not None:
+#                 raise ValueError(f'Failed to generate layout for section {curr_section}.')
             
-            layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
-            layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
-
-        consumption_log['h1_actor'].append((layout_cumulative_input_token, layout_cumulative_output_token))
-        total_input_token += layout_cumulative_input_token
-        total_output_token += layout_cumulative_output_token
-
-        h1_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1.pptx'
-        h2_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2.pptx'
-
-        h1_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1_filled.pptx'
-        h2_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2_filled.pptx'
-
-        ppt_to_images(h1_path, 'tmp/layout_h1')
-        ppt_to_images(h2_path, 'tmp/layout_h2')
-        ppt_to_images(h1_filled_path, 'tmp/layout_h1_filled')
-        ppt_to_images(h2_filled_path, 'tmp/layout_h2_filled')
-
-        h1_img = Image.open('tmp/layout_h1/slide_0001.jpg')
-        h2_img = Image.open('tmp/layout_h2/slide_0001.jpg')
-        h1_filled_img = Image.open('tmp/layout_h1_filled/slide_0001.jpg')
-        h2_filled_img = Image.open('tmp/layout_h2_filled/slide_0001.jpg')
-
-        h1_critic_msg = BaseMessage.make_user_message(
-            role_name='User',
-            content=h1_critic_template.render(),
-            image_list=[h1_neg_example, h1_pos_example, h1_filled_img]
-        )
-
-        outline_bbox_dict = {}
-        for k, v in outline_location.items():
-            outline_bbox_dict[k] = v['location']
-
-        bbox_check_result = check_bounding_boxes(
-            outline_bbox_dict, 
-            new_outline['meta']['width'], 
-            new_outline['meta']['height']
-        )
-
-        if len(bbox_check_result) != 0:
-            print(bbox_check_result)
-            attempt += 1
-            continue
-
-        h1_critic_agent.reset()
-        response = h1_critic_agent.step(h1_critic_msg)
-        input_token, output_token = account_token(response)
-        consumption_log['h1_critic'].append((input_token, output_token))
-        total_input_token += input_token
-        total_output_token += output_token
-        if response.msgs[0].content == 'T':
-            print('Blank area detected.')
-            attempt += 1
-            continue
-
-        break
-
-    outline_bbox_dict = {}
-    for k, v in outline_location.items():
-        outline_bbox_dict[k] = v['location']
-
-    # Generate subsection locations
-    outline_no_sub_locations = copy.deepcopy(new_outline)
-    if 'meta' in outline_no_sub_locations:
-        outline_no_sub_locations.pop('meta')
-
-    for k, v in outline_no_sub_locations.items():
-        if 'subsections' in v:
-            subsections = v['subsections']
-            for k_sub, v_sub in subsections.items():
-                del v_sub['location']
-                del v_sub['name']
-
-    h2_actor_template = jinja_env.from_string(config_h2_actor["template"])
-
-    h2_cumulative_input_token = 0
-    h2_cumulative_output_token = 0
+#             layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
+#             layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
+
+#         consumption_log['h1_actor'].append((layout_cumulative_input_token, layout_cumulative_output_token))
+#         total_input_token += layout_cumulative_input_token
+#         total_output_token += layout_cumulative_output_token
+
+#         h1_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1.pptx'
+#         h2_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2.pptx'
+
+#         h1_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1_filled.pptx'
+#         h2_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2_filled.pptx'
+
+#         ppt_to_images(h1_path, 'tmp/layout_h1')
+#         ppt_to_images(h2_path, 'tmp/layout_h2')
+#         ppt_to_images(h1_filled_path, 'tmp/layout_h1_filled')
+#         ppt_to_images(h2_filled_path, 'tmp/layout_h2_filled')
+
+#         h1_img = Image.open('tmp/layout_h1/slide_0001.jpg')
+#         h2_img = Image.open('tmp/layout_h2/slide_0001.jpg')
+#         h1_filled_img = Image.open('tmp/layout_h1_filled/slide_0001.jpg')
+#         h2_filled_img = Image.open('tmp/layout_h2_filled/slide_0001.jpg')
+
+#         h1_critic_msg = BaseMessage.make_user_message(
+#             role_name='User',
+#             content=h1_critic_template.render(),
+#             image_list=[h1_neg_example, h1_pos_example, h1_filled_img]
+#         )
+
+#         outline_bbox_dict = {}
+#         for k, v in outline_location.items():
+#             outline_bbox_dict[k] = v['location']
+
+#         bbox_check_result = check_bounding_boxes(
+#             outline_bbox_dict, 
+#             new_outline['meta']['width'], 
+#             new_outline['meta']['height']
+#         )
+
+#         if len(bbox_check_result) != 0:
+#             print(bbox_check_result)
+#             attempt += 1
+#             continue
+
+#         h1_critic_agent.reset()
+#         response = h1_critic_agent.step(h1_critic_msg)
+#         input_token, output_token = account_token(response)
+#         consumption_log['h1_critic'].append((input_token, output_token))
+#         total_input_token += input_token
+#         total_output_token += output_token
+#         if response.msgs[0].content == 'T':
+#             print('Blank area detected.')
+#             attempt += 1
+#             continue
+
+#         break
+
+#     outline_bbox_dict = {}
+#     for k, v in outline_location.items():
+#         outline_bbox_dict[k] = v['location']
+
+#     # Generate subsection locations
+#     outline_no_sub_locations = copy.deepcopy(new_outline)
+#     if 'meta' in outline_no_sub_locations:
+#         outline_no_sub_locations.pop('meta')
+
+#     for k, v in outline_no_sub_locations.items():
+#         if 'subsections' in v:
+#             subsections = v['subsections']
+#             for k_sub, v_sub in subsections.items():
+#                 del v_sub['location']
+#                 del v_sub['name']
+
+#     h2_actor_template = jinja_env.from_string(config_h2_actor["template"])
+
+#     h2_cumulative_input_token = 0
+#     h2_cumulative_output_token = 0
     
-    for section in sections:
-        while True:
-            print(f'generating h2 for section {section}...')
-            section_outline = {section: outline_no_sub_locations[section]}
-            section_jinja_args = {
-                'section_outline': json.dumps(section_outline, indent=4),
-            }
-
-            section_prompt = h2_actor_template.render(**section_jinja_args)
-
-            h2_actor_agent.reset()
-            response = h2_actor_agent.step(section_prompt)
-            input_token, output_token = account_token(response)
-            h2_cumulative_input_token += input_token
-            h2_cumulative_output_token += output_token
-            subsection_location = get_json_from_response(response.msgs[0].content)
-
-            sec_bbox = outline_no_sub_locations[section]['location']
-            subsection_location_dict = {}
-            for k, v in subsection_location.items():
-                subsection_location_dict[k] = {
-                    'left': v['location'][0],
-                    'top': v['location'][1],
-                    'width': v['location'][2],
-                    'height': v['location'][3]
-                }
-
-            is_valid, revised = validate_and_adjust_subsections(sec_bbox, subsection_location_dict)
-            if not is_valid:
-                is_valid, revised = validate_and_adjust_subsections(sec_bbox, revised)
-                assert is_valid, "Failed to adjust subsections to fit section"
-                outline_no_sub_locations = fill_location(outline_no_sub_locations, section, revised)
-            else:
-                outline_no_sub_locations = fill_location(outline_no_sub_locations, section, subsection_location)
-            break
-
-    consumption_log['h2_actor'].append((h2_cumulative_input_token, h2_cumulative_output_token))
-    total_input_token += h2_cumulative_input_token
-    total_output_token += h2_cumulative_output_token
-
-    outline_no_sub_locations['meta'] = outline['meta']
-    outline_no_sub_locations_with_name = recover_name_and_location(outline_no_sub_locations, new_outline)
-    new_outline = outline_no_sub_locations_with_name
-
-    ### Outline finalized, actually generate layout
-
-    logs = {}
-
-    gen_layout_cumulative_input_token = 0
-    gen_layout_cumulative_output_token = 0
-    curr_section = sections[0]
-
-    init_outline = {'meta': new_outline['meta'], sections[0]: new_outline[sections[0]]}
-
-    init_jinja_args = {
-        'json_outline': init_outline,
-        'function_docs': documentation
-    }
-
-    init_prompt = init_template.render(**init_jinja_args)
-    logs[curr_section] = gen_layout(
-        init_actor_agent, 
-        init_prompt, 
-        args.max_retry, 
-        name_to_hierarchy, 
-        visual_identifier=curr_section
-    )
-
-    if logs[curr_section][-1]['error'] is not None:
-        raise ValueError(f'Failed to generate layout for section {curr_section}.')
-
-    gen_layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
-    gen_layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
-
-    for section_index in range(1, len(sections)):
-        curr_section = sections[section_index]
-        print(f'generating section {curr_section}...')
-        new_section_outline = {curr_section: new_outline[curr_section]}
-        new_section_jinja_args = {
-            'json_outline': new_section_outline,
-            'function_docs': documentation
-        }
-        new_section_prompt = new_section_template.render(**new_section_jinja_args)
-
-        logs[curr_section] = gen_layout(
-            new_section_actor_agent, 
-            new_section_prompt, 
-            args.max_retry, 
-            name_to_hierarchy, 
-            visual_identifier=curr_section,
-            existing_code = logs[sections[section_index - 1]][-1]['concatenated_code']
-        )
-        if logs[curr_section][-1]['error'] is not None:
-            raise ValueError(f'Failed to generate layout for section {curr_section}.')
+#     for section in sections:
+#         while True:
+#             print(f'generating h2 for section {section}...')
+#             section_outline = {section: outline_no_sub_locations[section]}
+#             section_jinja_args = {
+#                 'section_outline': json.dumps(section_outline, indent=4),
+#             }
+
+#             section_prompt = h2_actor_template.render(**section_jinja_args)
+
+#             h2_actor_agent.reset()
+#             response = h2_actor_agent.step(section_prompt)
+#             input_token, output_token = account_token(response)
+#             h2_cumulative_input_token += input_token
+#             h2_cumulative_output_token += output_token
+#             subsection_location = get_json_from_response(response.msgs[0].content)
+
+#             sec_bbox = outline_no_sub_locations[section]['location']
+#             subsection_location_dict = {}
+#             for k, v in subsection_location.items():
+#                 subsection_location_dict[k] = {
+#                     'left': v['location'][0],
+#                     'top': v['location'][1],
+#                     'width': v['location'][2],
+#                     'height': v['location'][3]
+#                 }
+
+#             is_valid, revised = validate_and_adjust_subsections(sec_bbox, subsection_location_dict)
+#             if not is_valid:
+#                 is_valid, revised = validate_and_adjust_subsections(sec_bbox, revised)
+#                 assert is_valid, "Failed to adjust subsections to fit section"
+#                 outline_no_sub_locations = fill_location(outline_no_sub_locations, section, revised)
+#             else:
+#                 outline_no_sub_locations = fill_location(outline_no_sub_locations, section, subsection_location)
+#             break
+
+#     consumption_log['h2_actor'].append((h2_cumulative_input_token, h2_cumulative_output_token))
+#     total_input_token += h2_cumulative_input_token
+#     total_output_token += h2_cumulative_output_token
+
+#     outline_no_sub_locations['meta'] = outline['meta']
+#     outline_no_sub_locations_with_name = recover_name_and_location(outline_no_sub_locations, new_outline)
+#     new_outline = outline_no_sub_locations_with_name
+
+#     ### Outline finalized, actually generate layout
+
+#     logs = {}
+
+#     gen_layout_cumulative_input_token = 0
+#     gen_layout_cumulative_output_token = 0
+#     curr_section = sections[0]
+
+#     init_outline = {'meta': new_outline['meta'], sections[0]: new_outline[sections[0]]}
+
+#     init_jinja_args = {
+#         'json_outline': init_outline,
+#         'function_docs': documentation
+#     }
+
+#     init_prompt = init_template.render(**init_jinja_args)
+#     logs[curr_section] = gen_layout(
+#         init_actor_agent, 
+#         init_prompt, 
+#         args.max_retry, 
+#         name_to_hierarchy, 
+#         visual_identifier=curr_section
+#     )
+
+#     if logs[curr_section][-1]['error'] is not None:
+#         raise ValueError(f'Failed to generate layout for section {curr_section}.')
+
+#     gen_layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
+#     gen_layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
+
+#     for section_index in range(1, len(sections)):
+#         curr_section = sections[section_index]
+#         print(f'generating section {curr_section}...')
+#         new_section_outline = {curr_section: new_outline[curr_section]}
+#         new_section_jinja_args = {
+#             'json_outline': new_section_outline,
+#             'function_docs': documentation
+#         }
+#         new_section_prompt = new_section_template.render(**new_section_jinja_args)
+
+#         logs[curr_section] = gen_layout(
+#             new_section_actor_agent, 
+#             new_section_prompt, 
+#             args.max_retry, 
+#             name_to_hierarchy, 
+#             visual_identifier=curr_section,
+#             existing_code = logs[sections[section_index - 1]][-1]['concatenated_code']
+#         )
+#         if logs[curr_section][-1]['error'] is not None:
+#             raise ValueError(f'Failed to generate layout for section {curr_section}.')
         
-        gen_layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
-        gen_layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
-
-    consumption_log['gen_layout'].append((gen_layout_cumulative_input_token, gen_layout_cumulative_output_token))
-    total_input_token += gen_layout_cumulative_input_token
-    total_output_token += gen_layout_cumulative_output_token
-
-    h1_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1.pptx'
-    h2_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2.pptx'
-
-    h1_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1_filled.pptx'
-    h2_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2_filled.pptx'
-
-    ppt_to_images(h1_path, f'{poster_log_path}/layout_h1')
-    ppt_to_images(h2_path, f'{poster_log_path}/layout_h2')
-    ppt_to_images(h1_filled_path, f'{poster_log_path}/layout_h1_filled')
-    ppt_to_images(h2_filled_path, f'{poster_log_path}/layout_h2_filled')
-
-    h1_img = Image.open(f'{poster_log_path}/layout_h1/slide_0001.jpg')
-    h2_img = Image.open(f'{poster_log_path}/layout_h2/slide_0001.jpg')
-    h1_filled_img = Image.open(f'{poster_log_path}/layout_h1_filled/slide_0001.jpg')
-    h2_filled_img = Image.open(f'{poster_log_path}/layout_h2_filled/slide_0001.jpg')
-
-    ckpt = {
-        'logs': logs,
-        'outline': new_outline,
-        'name_to_hierarchy': name_to_hierarchy,
-        'consumption_log': consumption_log,
-        'total_input_token': total_input_token,
-        'total_output_token': total_output_token,
-    }
-
-    with open(f'checkpoints/{args.model_name}_{args.poster_name}_ckpt_{args.index}.pkl', 'wb') as f:
-        pkl.dump(ckpt, f)
-
-    json.dump(
-        new_outline,
-        open(outline_file_path, "w"),
-        ensure_ascii=False,
-        indent=4,
-    )
-
-    return total_input_token, total_output_token
+#         gen_layout_cumulative_input_token += logs[curr_section][-1]['cumulative_tokens'][0]
+#         gen_layout_cumulative_output_token += logs[curr_section][-1]['cumulative_tokens'][1]
+
+#     consumption_log['gen_layout'].append((gen_layout_cumulative_input_token, gen_layout_cumulative_output_token))
+#     total_input_token += gen_layout_cumulative_input_token
+#     total_output_token += gen_layout_cumulative_output_token
+
+#     h1_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1.pptx'
+#     h2_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2.pptx'
+
+#     h1_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_1_filled.pptx'
+#     h2_filled_path = f'tmp/poster_<{sections[-1]}>_hierarchy_2_filled.pptx'
+
+#     ppt_to_images(h1_path, f'{poster_log_path}/layout_h1')
+#     ppt_to_images(h2_path, f'{poster_log_path}/layout_h2')
+#     ppt_to_images(h1_filled_path, f'{poster_log_path}/layout_h1_filled')
+#     ppt_to_images(h2_filled_path, f'{poster_log_path}/layout_h2_filled')
+
+#     h1_img = Image.open(f'{poster_log_path}/layout_h1/slide_0001.jpg')
+#     h2_img = Image.open(f'{poster_log_path}/layout_h2/slide_0001.jpg')
+#     h1_filled_img = Image.open(f'{poster_log_path}/layout_h1_filled/slide_0001.jpg')
+#     h2_filled_img = Image.open(f'{poster_log_path}/layout_h2_filled/slide_0001.jpg')
+
+#     ckpt = {
+#         'logs': logs,
+#         'outline': new_outline,
+#         'name_to_hierarchy': name_to_hierarchy,
+#         'consumption_log': consumption_log,
+#         'total_input_token': total_input_token,
+#         'total_output_token': total_output_token,
+#     }
+
+#     with open(f'checkpoints/{args.model_name}_{args.poster_name}_ckpt_{args.index}.pkl', 'wb') as f:
+#         pkl.dump(ckpt, f)
+
+#     json.dump(
+#         new_outline,
+#         open(outline_file_path, "w"),
+#         ensure_ascii=False,
+#         indent=4,
+#     )
+
+#     return total_input_token, total_output_token
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()

Paper2Poster/PosterAgent/new_pipeline.py

@@ -2,15 +2,15 @@ import os
 print("Initializing...")
 from PosterAgent.parse_raw import parse_raw, gen_image_and_table
 from PosterAgent.gen_outline_layout import filter_image_table, gen_outline_layout_v2
-from utils.wei_utils import get_agent_config, utils_functions, run_code, scale_to_target_area, char_capacity
-from PosterAgent.tree_split_layout import main_train, main_inference, get_arrangments_in_inches, split_textbox, to_inches
+from utils.wei_utils import get_agent_config, scale_to_target_area
+# from PosterAgent.tree_split_layout import main_train, main_inference, get_arrangments_in_inches, split_textbox, to_inches
 # from PosterAgent.gen_pptx_code import generate_poster_code
 # from utils.src.utils import ppt_to_images
 # from PosterAgent.gen_poster_content import gen_bullet_point_content
-from utils.ablation_utils import no_tree_get_layout
+# from utils.ablation_utils import no_tree_get_layout
 
 # Import refactored utilities
-from utils.logo_utils import LogoManager, add_logos_to_poster_code
+# from utils.logo_utils import LogoManager, add_logos_to_poster_code
 # from utils.config_utils import (
 #     load_poster_yaml_config, extract_font_sizes, extract_colors,
 #     extract_vertical_alignment, extract_section_title_symbol, normalize_config_values
@@ -32,6 +32,14 @@ import time
 import shutil
 
 units_per_inch = 25
+def to_inches(value_in_units, units_per_inch=72):
+    """
+    Convert a single coordinate or dimension from 'units' to inches.
+    For example, if your units are 'points' (72 points = 1 inch),
+    then units_per_inch=72.
+    If your units are 'pixels' at 96 DPI, then units_per_inch=96.
+    """
+    return value_in_units / units_per_inch
 
 if __name__ == '__main__':
 

Paper2Poster/PosterAgent/parse_raw.py

@@ -27,7 +27,7 @@ import torch
 from jinja2 import Template
 import re
 import argparse
-
+import os
 load_dotenv()
 IMAGE_RESOLUTION_SCALE = 5.0
 
@@ -41,70 +41,103 @@ doc_converter = DocumentConverter(
         InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options)
     }
 )
+def account_token(response):
+    input_token = response.info['usage']['prompt_tokens']
+    output_token = response.info['usage']['completion_tokens']
+
+    return input_token, output_token
 
 @retry(stop=stop_after_attempt(5))
 def parse_raw(args, actor_config, version=2):
     raw_source = args.poster_path
     markdown_clean_pattern = re.compile(r"<!--[\s\S]*?-->")
+    print(f'\nParsing raw content from {raw_source}...\n')
+    try:
+        raw_result = doc_converter.convert(raw_source)
+        print('✅ PDF converted to document format.')
+        raw_markdown = raw_result.document.export_to_markdown()
+        text_content = markdown_clean_pattern.sub("", raw_markdown)
+        print(f'Extracted {len(text_content)} characters from the document.')
+        if len(text_content) < 500:
+            print('\nParsing with docling failed, using marker instead\n')
+            parser_model = create_model_dict(device='cuda', dtype=torch.float16)
+            text_content, rendered = parse_pdf(raw_source, model_lst=parser_model, save_file=False)
+    except Exception as e:
+        print(f'❌ PDF parsing failed: {e}')
+        raise e
+
+    # Load prompt template safely
+    try:
+        if version == 1:
+            template = Template(open("utils/prompts/gen_poster_raw_content.txt").read())
+        elif version == 2:
+            print('Using v2 prompt template')
+            template = Template(open("utils/prompts/gen_poster_raw_content_v2.txt").read())
+        else:
+            raise ValueError("Invalid version number.")
+    except Exception as e:
+        print(f'❌ Failed to load prompt template: {e}')
+        raise e
+
+    # Initialize actor model
+    try:
+        if args.model_name_t.startswith('vllm_qwen'):
+            actor_model = ModelFactory.create(
+                model_platform=actor_config['model_platform'],
+                model_type=actor_config['model_type'],
+                model_config_dict=actor_config['model_config'],
+                url=actor_config['url'],
+            )
+        else:
+            actor_model = ModelFactory.create(
+                model_platform=actor_config['model_platform'],
+                model_type=actor_config['model_type'],
+                model_config_dict=actor_config['model_config'],
+            )
 
-    raw_result = doc_converter.convert(raw_source)
-
-    raw_markdown = raw_result.document.export_to_markdown()
-    text_content = markdown_clean_pattern.sub("", raw_markdown)
-
-    if len(text_content) < 500:
-        print('\nParsing with docling failed, using marker instead\n')
-        parser_model = create_model_dict(device='cuda', dtype=torch.float16)
-        text_content, rendered = parse_pdf(raw_source, model_lst=parser_model, save_file=False)
-
-    if version == 1:
-        template = Template(open("utils/prompts/gen_poster_raw_content.txt").read())
-    elif version == 2:
-        print('Using v2 prompt template')
-        template = Template(open("utils/prompts/gen_poster_raw_content_v2.txt").read())
-
-    if args.model_name_t.startswith('vllm_qwen'):
-        actor_model = ModelFactory.create(
-            model_platform=actor_config['model_platform'],
-            model_type=actor_config['model_type'],
-            model_config_dict=actor_config['model_config'],
-            url=actor_config['url'],
+        actor_sys_msg = 'You are the author of the paper, and you will create a poster for the paper.'
+        actor_agent = ChatAgent(
+            system_message=actor_sys_msg,
+            model=actor_model,
+            message_window_size=10,
+            token_limit=actor_config.get('token_limit', None)
         )
+    except Exception as e:
+        print(f'❌ Failed to initialize actor model: {e}')
+        raise e
+
+    # === main conversation loop ===
+    max_retry = 5
+    content_json = {}
+    for attempt in range(max_retry):
+        try:
+            print(f'\n🌀 Generating poster content... (Attempt {attempt+1}/{max_retry})')
+            prompt = template.render(markdown_document=text_content)
+            actor_agent.reset()
+            response = actor_agent.step(prompt)
+            input_token, output_token = account_token(response)
+
+            content_json = get_json_from_response(response.msgs[0].content)
+            if len(content_json) > 0:
+                print('✅ Successfully parsed JSON content.')
+                break
+            else:
+                print('⚠️ Empty JSON response, retrying...')
+                if args.model_name_t.startswith('vllm_qwen'):
+                    text_content = text_content[:80000]
+        except Exception as e:
+            print(f'❌ Error in actor_agent loop: {e}')
+        # short delay could be added if needed
     else:
-        actor_model = ModelFactory.create(
-            model_platform=actor_config['model_platform'],
-            model_type=actor_config['model_type'],
-            model_config_dict=actor_config['model_config'],
+        raise RuntimeError("Failed to get valid JSON content after multiple attempts.")
+
+    # Trim sections if too many
+    if len(content_json.get('sections', [])) > 9:
+        selected_sections = (
+            content_json['sections'][:2]
+            + random.sample(content_json['sections'][2:-2], 5)
+            + content_json['sections'][-2:]
         )
-
-    actor_sys_msg = 'You are the author of the paper, and you will create a poster for the paper.'
-
-    actor_agent = ChatAgent(
-        system_message=actor_sys_msg,
-        model=actor_model,
-        message_window_size=10,
-        token_limit=actor_config.get('token_limit', None)
-    )
-
-    while True:
-        prompt = template.render(
-            markdown_document=text_content, 
-        )
-        actor_agent.reset()
-        response = actor_agent.step(prompt)
-        input_token, output_token = account_token(response)
-
-        content_json = get_json_from_response(response.msgs[0].content)
-
-        if len(content_json) > 0:
-            break
-        print('Error: Empty response, retrying...')
-        if args.model_name_t.startswith('vllm_qwen'):
-            text_content = text_content[:80000]
-
-    if len(content_json['sections']) > 9:
-        # First 2 sections + randomly select 5 sections + last 2 sections
-        selected_sections = content_json['sections'][:2] + random.sample(content_json['sections'][2:-2], 5) + content_json['sections'][-2:]
         content_json['sections'] = selected_sections
 
     has_title = False

Paper2Poster/utils/__init__.py

@@ -1 +1 @@
-from . import poster_eval_utils, pptx_utils, wei_utils, critic_utils, ablation_utils, src
+from . import  wei_utils,  src

Paper2Poster/utils/src/__init__.py

@@ -1,5 +1,5 @@
 from . import (
     model_utils,
-    presentation,
-    utils
+    # presentation,
+    # utils
 )

Paper2Poster/utils/src/model_utils.py

@@ -14,7 +14,8 @@ from PIL import Image
 # from transformers import AutoFeatureExtractor, AutoModel
 
 # from utils.src.presentation import Presentation, SlidePage
-from utils.src.utils import is_image_path, pjoin
+# from utils.src.utils import is_image_path, pjoin
+pjoin = os.path.join
 
 # device_count = torch.cuda.device_count()
 

Paper2Poster/utils/wei_utils.py

@@ -1,27 +1,27 @@
-import re
-import io
-import contextlib
-import traceback
-from pptx import Presentation
-from pptx.enum.shapes import MSO_SHAPE_TYPE, MSO_SHAPE, MSO_AUTO_SHAPE_TYPE
-from pptx.util import Inches, Pt
-from pptx.dml.color import RGBColor
-from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
+# import re
+# import io
+# import contextlib
+# import traceback
+# from pptx import Presentation
+# from pptx.enum.shapes import MSO_SHAPE_TYPE, MSO_SHAPE, MSO_AUTO_SHAPE_TYPE
+# from pptx.util import Inches, Pt
+# from pptx.dml.color import RGBColor
+# from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
 from camel.types import ModelPlatformType, ModelType
 from camel.configs import ChatGPTConfig, QwenConfig, VLLMConfig, OpenRouterConfig, GeminiConfig
 import math
-from urllib.parse import quote_from_bytes, quote
-from PIL import Image
-import os
-import copy
-import io
-from utils.src.utils import ppt_to_images
-from playwright.sync_api import sync_playwright
-from pathlib import Path
-from playwright.async_api import async_playwright
-import asyncio
-from utils.pptx_utils import *
-from utils.critic_utils import *
+# from urllib.parse import quote_from_bytes, quote
+# from PIL import Image
+# import os
+# import copy
+# import io
+# from utils.src.utils import ppt_to_images
+# from playwright.sync_api import sync_playwright
+# from pathlib import Path
+# from playwright.async_api import async_playwright
+# import asyncio
+# from utils.pptx_utils import *
+# from utils.critic_utils import *
 
 def get_agent_config(model_type):
     agent_config = {}
@@ -196,795 +196,795 @@ def get_agent_config(model_type):
     return agent_config
 
 
-def match_response(response):
-    response_text = response.msgs[0].content
+# def match_response(response):
+#     response_text = response.msgs[0].content
 
-    # This regular expression looks for text between ```python ... ```
-    pattern = r'```python(.*?)```'
-    match = re.search(pattern, response_text, flags=re.DOTALL)
+#     # This regular expression looks for text between ```python ... ```
+#     pattern = r'```python(.*?)```'
+#     match = re.search(pattern, response_text, flags=re.DOTALL)
 
-    if not match:
-        pattern = r'```(.*?)```'
-        match = re.search(pattern, response_text, flags=re.DOTALL)
+#     if not match:
+#         pattern = r'```(.*?)```'
+#         match = re.search(pattern, response_text, flags=re.DOTALL)
 
-    if match:
-        code_snippet = match.group(1).strip()
-    else:
-        # If there's no fenced code block, fallback to entire response or handle error
-        code_snippet = response_text
-    return code_snippet
+#     if match:
+#         code_snippet = match.group(1).strip()
+#     else:
+#         # If there's no fenced code block, fallback to entire response or handle error
+#         code_snippet = response_text
+#     return code_snippet
 
-def run_code_with_utils(code, utils_functions):
-    return run_code(utils_functions + '\n' + code)
+# def run_code_with_utils(code, utils_functions):
+#     return run_code(utils_functions + '\n' + code)
 
-def run_code(code):
-    """
-    Execute Python code and capture stdout as well as the full stack trace on error.
-    Forces __name__ = "__main__" so that if __name__ == "__main__": blocks will run.
+# def run_code(code):
+#     """
+#     Execute Python code and capture stdout as well as the full stack trace on error.
+#     Forces __name__ = "__main__" so that if __name__ == "__main__": blocks will run.
     
-    Returns:
-        (output, error)
-        - output: string containing everything that was printed to stdout
-        - error: string containing the full traceback if an exception occurred; None otherwise
-    """
-    stdout_capture = io.StringIO()
-    # Provide a globals dict specifying that __name__ is "__main__"
-    exec_globals = {"__name__": "__main__"}
-
-    with contextlib.redirect_stdout(stdout_capture):
-        try:
-            exec(code, exec_globals)
-            error = None
-        except Exception:
-            # Capture the entire stack trace
-            error = traceback.format_exc()
-
-    output = stdout_capture.getvalue()
-    return output, error
-
-
-def run_code_from_agent(agent, msg, num_retries=1):
-    agent.reset()
-    log = []
-    for attempt in range(num_retries + 1):  # +1 to include the initial attempt
-        response = agent.step(msg)
-        code = match_response(response)
-        output, error = run_code(code)
-        log.append((code, output, error))
+#     Returns:
+#         (output, error)
+#         - output: string containing everything that was printed to stdout
+#         - error: string containing the full traceback if an exception occurred; None otherwise
+#     """
+#     stdout_capture = io.StringIO()
+#     # Provide a globals dict specifying that __name__ is "__main__"
+#     exec_globals = {"__name__": "__main__"}
+
+#     with contextlib.redirect_stdout(stdout_capture):
+#         try:
+#             exec(code, exec_globals)
+#             error = None
+#         except Exception:
+#             # Capture the entire stack trace
+#             error = traceback.format_exc()
+
+#     output = stdout_capture.getvalue()
+#     return output, error
+
+
+# def run_code_from_agent(agent, msg, num_retries=1):
+#     agent.reset()
+#     log = []
+#     for attempt in range(num_retries + 1):  # +1 to include the initial attempt
+#         response = agent.step(msg)
+#         code = match_response(response)
+#         output, error = run_code(code)
+#         log.append((code, output, error))
         
-        if error is None:
-            return log
+#         if error is None:
+#             return log
         
-        if attempt < num_retries:
-            print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
-            msg = error
+#         if attempt < num_retries:
+#             print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
+#             msg = error
     
-    return log
-
-def run_modular(all_code, file_name, with_border=True, with_label=True):
-    concatenated_code = utils_functions
-    concatenated_code += "\n".join(all_code.values())
-    if with_border and with_label:
-        concatenated_code += add_border_label_function
-        concatenated_code += create_id_map_function
-        concatenated_code += save_helper_info_border_label.format(file_name, file_name, file_name)
-    elif with_border:
-        concatenated_code += add_border_function
-        concatenated_code += save_helper_info_border.format(file_name, file_name)
-    else:
-        concatenated_code += f'\nposter.save("{file_name}")'
-    output, error = run_code(concatenated_code)
-    return concatenated_code, output, error
-
-def edit_modular(
-        agent,
-        edit_section_name, 
-        feedback,
-        all_code, 
-        file_name, 
-        outline,
-        content,
-        images,
-        actor_prompt,
-        num_retries=1,
-        prompt_type='initial'
-    ):
-    agent.reset()
-    log = []
-    if prompt_type == 'initial':
-        msg = actor_prompt.format(
-            outline['meta'],
-            {edit_section_name: outline[edit_section_name]}, 
-            content, 
-            images,
-            documentation
-        )
-    elif prompt_type == 'edit':
-        assert (edit_section_name == list(feedback.keys())[0])
-        msg = actor_prompt.format(
-            edit_section_name,
-            all_code[edit_section_name],
-            feedback,
-            {edit_section_name: outline[edit_section_name]}, 
-            content, 
-            images,
-            documentation
-        )
-    elif prompt_type == 'new':
-        assert (list(feedback.keys())[0] == 'all_good')
-        msg = actor_prompt.format(
-            {edit_section_name: outline[edit_section_name]}, 
-            content, 
-            images,
-            documentation
-        )
-
-    for attempt in range(num_retries + 1):
-        response = agent.step(msg)
-        new_code = match_response(response)
-        all_code_changed = all_code.copy()
-        all_code_changed[edit_section_name] = new_code
-        concatenated_code, output, error = run_modular(all_code_changed, file_name, False, False)
-        log.append({
-            "code": new_code,
-            "output": output,
-            "error": error,
-            "concatenated_code": concatenated_code
-        })
-        if error is None:
-            return log
+#     return log
+
+# def run_modular(all_code, file_name, with_border=True, with_label=True):
+#     concatenated_code = utils_functions
+#     concatenated_code += "\n".join(all_code.values())
+#     if with_border and with_label:
+#         concatenated_code += add_border_label_function
+#         concatenated_code += create_id_map_function
+#         concatenated_code += save_helper_info_border_label.format(file_name, file_name, file_name)
+#     elif with_border:
+#         concatenated_code += add_border_function
+#         concatenated_code += save_helper_info_border.format(file_name, file_name)
+#     else:
+#         concatenated_code += f'\nposter.save("{file_name}")'
+#     output, error = run_code(concatenated_code)
+#     return concatenated_code, output, error
+
+# def edit_modular(
+#         agent,
+#         edit_section_name, 
+#         feedback,
+#         all_code, 
+#         file_name, 
+#         outline,
+#         content,
+#         images,
+#         actor_prompt,
+#         num_retries=1,
+#         prompt_type='initial'
+#     ):
+#     agent.reset()
+#     log = []
+#     if prompt_type == 'initial':
+#         msg = actor_prompt.format(
+#             outline['meta'],
+#             {edit_section_name: outline[edit_section_name]}, 
+#             content, 
+#             images,
+#             documentation
+#         )
+#     elif prompt_type == 'edit':
+#         assert (edit_section_name == list(feedback.keys())[0])
+#         msg = actor_prompt.format(
+#             edit_section_name,
+#             all_code[edit_section_name],
+#             feedback,
+#             {edit_section_name: outline[edit_section_name]}, 
+#             content, 
+#             images,
+#             documentation
+#         )
+#     elif prompt_type == 'new':
+#         assert (list(feedback.keys())[0] == 'all_good')
+#         msg = actor_prompt.format(
+#             {edit_section_name: outline[edit_section_name]}, 
+#             content, 
+#             images,
+#             documentation
+#         )
+
+#     for attempt in range(num_retries + 1):
+#         response = agent.step(msg)
+#         new_code = match_response(response)
+#         all_code_changed = all_code.copy()
+#         all_code_changed[edit_section_name] = new_code
+#         concatenated_code, output, error = run_modular(all_code_changed, file_name, False, False)
+#         log.append({
+#             "code": new_code,
+#             "output": output,
+#             "error": error,
+#             "concatenated_code": concatenated_code
+#         })
+#         if error is None:
+#             return log
         
-        if attempt < num_retries:
-            print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
-            msg = error
-            msg += '\nFix your code and try again. The poster is a single-page pptx.'
-            if prompt_type != 'initial':
-                msg += '\nAssume that you have had a Presentation object named "poster" and a slide named "slide".'
-
-    return log
-
-def add_border_to_all_elements(prs, border_color=RGBColor(255, 0, 0), border_width=Pt(2)):
-    """
-    Iterates over all slides and shapes in the Presentation object 'prs'
-    and applies a red border with the specified width to each shape.
+#         if attempt < num_retries:
+#             print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
+#             msg = error
+#             msg += '\nFix your code and try again. The poster is a single-page pptx.'
+#             if prompt_type != 'initial':
+#                 msg += '\nAssume that you have had a Presentation object named "poster" and a slide named "slide".'
+
+#     return log
+
+# def add_border_to_all_elements(prs, border_color=RGBColor(255, 0, 0), border_width=Pt(2)):
+#     """
+#     Iterates over all slides and shapes in the Presentation object 'prs'
+#     and applies a red border with the specified width to each shape.
     
-    Args:
-        prs: The Presentation object to modify.
-        border_color: An instance of RGBColor for the border color (default is red).
-        border_width: The width of the border as a Pt value (default is 2 points).
-    """
-    for slide in prs.slides:
-        for shape in slide.shapes:
-            # Some shapes (like charts or group shapes) might not support border styling
-            try:
-                # Set the line fill to be solid and assign the desired color and width.
-                shape.line.fill.solid()
-                shape.line.fill.fore_color.rgb = border_color
-                shape.line.width = border_width
-            except Exception as e:
-                # If a shape doesn't support setting a border, print a message and continue.
-                print(f"Could not add border to shape {shape.shape_type}: {e}")
-
-
-# 1 point = 12700 EMUs (helper function)
-def pt_to_emu(points: float) -> int:
-    return int(points * 12700)
-
-def add_border_and_labels(
-    prs,
-    border_color=RGBColor(255, 0, 0),   # Red border for shapes
-    border_width=Pt(2),                # 2-point border width
-    label_outline_color=RGBColor(0, 0, 255),  # Blue outline for label circle
-    label_text_color=RGBColor(0, 0, 255),     # Blue text color
-    label_diameter_pt=40                       # Diameter of the label circle in points
-):
-    """
-    Iterates over all slides and shapes in the Presentation 'prs', applies a 
-    red border to each shape, and places a transparent (no fill), blue-outlined 
-    circular label with a blue number in the center of each shape. Labels start 
-    from 0 and increment for every shape that gets a border.
-
-    Args:
-        prs: The Presentation object to modify.
-        border_color: RGBColor for the shape border color (default: red).
-        border_width: The width of the shape border (Pt).
-        label_outline_color: The outline color for the label circle (default: blue).
-        label_text_color: The color of the label text (default: blue).
-        label_diameter_pt: The diameter of the label circle, in points (default: 40).
-    """
-    label_diameter_emu = pt_to_emu(label_diameter_pt)  # convert diameter (points) to EMUs
-    label_counter = 0  # Start labeling at 0
-    labeled_elements = {}
-
-    for slide in prs.slides:
-        for shape in slide.shapes:
-            # Skip shapes that are labels themselves
-            if shape.name.startswith("Label_"):
-                continue
-
-            try:
-                # --- 1) Add red border to the shape (if supported) ---
-                shape.line.fill.solid()
-                shape.line.fill.fore_color.rgb = border_color
-                shape.line.width = border_width
-
-                # --- 2) Calculate center for the label circle ---
-                label_left = shape.left + (shape.width // 2) - (label_diameter_emu // 2)
-                label_top  = shape.top  + (shape.height // 2) - (label_diameter_emu // 2)
-
-                # --- 3) Create label circle (an OVAL) in the center of the shape ---
-                label_shape = slide.shapes.add_shape(
-                    MSO_AUTO_SHAPE_TYPE.OVAL,
-                    label_left,
-                    label_top,
-                    label_diameter_emu,
-                    label_diameter_emu
-                )
-                label_shape.name = f"Label_{label_counter}"  # so we can skip it later
-
-                # **Make the circle completely transparent** (no fill at all)
-                label_shape.fill.background()
-
-                # **Give it a blue outline**
-                label_shape.line.fill.solid()
-                label_shape.line.fill.fore_color.rgb = label_outline_color
-                label_shape.line.width = Pt(3)
-
-                # --- 4) Add the label number (centered, blue text) ---
-                tf = label_shape.text_frame
-                tf.text = str(label_counter)
-                paragraph = tf.paragraphs[0]
-                paragraph.alignment = PP_ALIGN.CENTER
-
-                run = paragraph.runs[0]
-                font = run.font
-                font.size = Pt(40)      # Larger font
-                font.bold = True
-                font.name = "Arial"
-                font._element.get_or_change_to_solidFill()
-                font.fill.fore_color.rgb = label_text_color
-                # Record properties from the original shape and label text.
-                labeled_elements[label_counter] = {
-                    'left': f'{shape.left} EMU',
-                    'top': f'{shape.top} EMU',
-                    'width': f'{shape.width} EMU',
-                    'height': f'{shape.height} EMU',
-                    'font_size': f'{shape.text_frame.font.size} PT' if hasattr(shape, 'text_frame') else None,
-                }
-
-                # --- 5) Increment label counter (so every shape has a unique label) ---
-                label_counter += 1
-
-            except Exception as e:
-                # If the shape doesn't support borders or text, skip gracefully
-                print(f"Could not add border/label to shape (type={shape.shape_type}): {e}")
-
-    return labeled_elements
-
-
-def fill_content(agent, prompt, num_retries, existing_code=''):
-    if existing_code == '':
-        existing_code = utils_functions
-    agent.reset()
-    log = []
-    cumulative_input_token, cumulative_output_token = 0, 0
-    for attempt in range(num_retries + 1):
-        response = agent.step(prompt)
-        input_token, output_token = account_token(response)
-        cumulative_input_token += input_token
-        cumulative_output_token += output_token
-        new_code = match_response(response)
-        all_code = existing_code + '\n' + new_code
-
-        output, error = run_code(all_code)
-        log.append({
-            "code": new_code,
-            "output": output,
-            "error": error,
-            "concatenated_code": all_code,
-            'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
-        })
-
-        if error is None:
-            return log
+#     Args:
+#         prs: The Presentation object to modify.
+#         border_color: An instance of RGBColor for the border color (default is red).
+#         border_width: The width of the border as a Pt value (default is 2 points).
+#     """
+#     for slide in prs.slides:
+#         for shape in slide.shapes:
+#             # Some shapes (like charts or group shapes) might not support border styling
+#             try:
+#                 # Set the line fill to be solid and assign the desired color and width.
+#                 shape.line.fill.solid()
+#                 shape.line.fill.fore_color.rgb = border_color
+#                 shape.line.width = border_width
+#             except Exception as e:
+#                 # If a shape doesn't support setting a border, print a message and continue.
+#                 print(f"Could not add border to shape {shape.shape_type}: {e}")
+
+
+# # 1 point = 12700 EMUs (helper function)
+# def pt_to_emu(points: float) -> int:
+#     return int(points * 12700)
+
+# def add_border_and_labels(
+#     prs,
+#     border_color=RGBColor(255, 0, 0),   # Red border for shapes
+#     border_width=Pt(2),                # 2-point border width
+#     label_outline_color=RGBColor(0, 0, 255),  # Blue outline for label circle
+#     label_text_color=RGBColor(0, 0, 255),     # Blue text color
+#     label_diameter_pt=40                       # Diameter of the label circle in points
+# ):
+#     """
+#     Iterates over all slides and shapes in the Presentation 'prs', applies a 
+#     red border to each shape, and places a transparent (no fill), blue-outlined 
+#     circular label with a blue number in the center of each shape. Labels start 
+#     from 0 and increment for every shape that gets a border.
+
+#     Args:
+#         prs: The Presentation object to modify.
+#         border_color: RGBColor for the shape border color (default: red).
+#         border_width: The width of the shape border (Pt).
+#         label_outline_color: The outline color for the label circle (default: blue).
+#         label_text_color: The color of the label text (default: blue).
+#         label_diameter_pt: The diameter of the label circle, in points (default: 40).
+#     """
+#     label_diameter_emu = pt_to_emu(label_diameter_pt)  # convert diameter (points) to EMUs
+#     label_counter = 0  # Start labeling at 0
+#     labeled_elements = {}
+
+#     for slide in prs.slides:
+#         for shape in slide.shapes:
+#             # Skip shapes that are labels themselves
+#             if shape.name.startswith("Label_"):
+#                 continue
+
+#             try:
+#                 # --- 1) Add red border to the shape (if supported) ---
+#                 shape.line.fill.solid()
+#                 shape.line.fill.fore_color.rgb = border_color
+#                 shape.line.width = border_width
+
+#                 # --- 2) Calculate center for the label circle ---
+#                 label_left = shape.left + (shape.width // 2) - (label_diameter_emu // 2)
+#                 label_top  = shape.top  + (shape.height // 2) - (label_diameter_emu // 2)
+
+#                 # --- 3) Create label circle (an OVAL) in the center of the shape ---
+#                 label_shape = slide.shapes.add_shape(
+#                     MSO_AUTO_SHAPE_TYPE.OVAL,
+#                     label_left,
+#                     label_top,
+#                     label_diameter_emu,
+#                     label_diameter_emu
+#                 )
+#                 label_shape.name = f"Label_{label_counter}"  # so we can skip it later
+
+#                 # **Make the circle completely transparent** (no fill at all)
+#                 label_shape.fill.background()
+
+#                 # **Give it a blue outline**
+#                 label_shape.line.fill.solid()
+#                 label_shape.line.fill.fore_color.rgb = label_outline_color
+#                 label_shape.line.width = Pt(3)
+
+#                 # --- 4) Add the label number (centered, blue text) ---
+#                 tf = label_shape.text_frame
+#                 tf.text = str(label_counter)
+#                 paragraph = tf.paragraphs[0]
+#                 paragraph.alignment = PP_ALIGN.CENTER
+
+#                 run = paragraph.runs[0]
+#                 font = run.font
+#                 font.size = Pt(40)      # Larger font
+#                 font.bold = True
+#                 font.name = "Arial"
+#                 font._element.get_or_change_to_solidFill()
+#                 font.fill.fore_color.rgb = label_text_color
+#                 # Record properties from the original shape and label text.
+#                 labeled_elements[label_counter] = {
+#                     'left': f'{shape.left} EMU',
+#                     'top': f'{shape.top} EMU',
+#                     'width': f'{shape.width} EMU',
+#                     'height': f'{shape.height} EMU',
+#                     'font_size': f'{shape.text_frame.font.size} PT' if hasattr(shape, 'text_frame') else None,
+#                 }
+
+#                 # --- 5) Increment label counter (so every shape has a unique label) ---
+#                 label_counter += 1
+
+#             except Exception as e:
+#                 # If the shape doesn't support borders or text, skip gracefully
+#                 print(f"Could not add border/label to shape (type={shape.shape_type}): {e}")
+
+#     return labeled_elements
+
+
+# def fill_content(agent, prompt, num_retries, existing_code=''):
+#     if existing_code == '':
+#         existing_code = utils_functions
+#     agent.reset()
+#     log = []
+#     cumulative_input_token, cumulative_output_token = 0, 0
+#     for attempt in range(num_retries + 1):
+#         response = agent.step(prompt)
+#         input_token, output_token = account_token(response)
+#         cumulative_input_token += input_token
+#         cumulative_output_token += output_token
+#         new_code = match_response(response)
+#         all_code = existing_code + '\n' + new_code
+
+#         output, error = run_code(all_code)
+#         log.append({
+#             "code": new_code,
+#             "output": output,
+#             "error": error,
+#             "concatenated_code": all_code,
+#             'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
+#         })
+
+#         if error is None:
+#             return log
         
-        if attempt < num_retries:
-            print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
-            prompt = error
-    return log
-
-def apply_theme(agent, prompt, num_retries, existing_code=''):
-    return fill_content(agent, prompt, num_retries, existing_code)
-
-def edit_code(agent, prompt, num_retries, existing_code=''):
-    return fill_content(agent, prompt, num_retries, existing_code)
-
-def stylize(agent, prompt, num_retries, existing_code=''):
-    return fill_content(agent, prompt, num_retries, existing_code)
-
-def gen_layout(agent, prompt, num_retries, name_to_hierarchy, visual_identifier='', existing_code=''):
-    if existing_code == '':
-        existing_code = utils_functions
-    agent.reset()
-    log = []
-    cumulative_input_token, cumulative_output_token = 0, 0
-    for attempt in range(num_retries + 1):
-        response = agent.step(prompt)
-        input_token, output_token = account_token(response)
-        cumulative_input_token += input_token
-        cumulative_output_token += output_token
-        new_code = match_response(response)
-        all_code = existing_code + '\n' + new_code
-
-        # Save visualizations
-        all_code += f'''
-name_to_hierarchy = {name_to_hierarchy}
-identifier = "{visual_identifier}"
-get_visual_cues(name_to_hierarchy, identifier)
-'''
-
-        output, error = run_code(all_code)
-        log.append({
-            "code": new_code,
-            "output": output,
-            "error": error,
-            "concatenated_code": all_code,
-            'num_tokens': (input_token, output_token),
-            'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
-        })
-
-        if error is None:
-            return log
+#         if attempt < num_retries:
+#             print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
+#             prompt = error
+#     return log
+
+# def apply_theme(agent, prompt, num_retries, existing_code=''):
+#     return fill_content(agent, prompt, num_retries, existing_code)
+
+# def edit_code(agent, prompt, num_retries, existing_code=''):
+#     return fill_content(agent, prompt, num_retries, existing_code)
+
+# def stylize(agent, prompt, num_retries, existing_code=''):
+#     return fill_content(agent, prompt, num_retries, existing_code)
+
+# def gen_layout(agent, prompt, num_retries, name_to_hierarchy, visual_identifier='', existing_code=''):
+#     if existing_code == '':
+#         existing_code = utils_functions
+#     agent.reset()
+#     log = []
+#     cumulative_input_token, cumulative_output_token = 0, 0
+#     for attempt in range(num_retries + 1):
+#         response = agent.step(prompt)
+#         input_token, output_token = account_token(response)
+#         cumulative_input_token += input_token
+#         cumulative_output_token += output_token
+#         new_code = match_response(response)
+#         all_code = existing_code + '\n' + new_code
+
+#         # Save visualizations
+#         all_code += f'''
+# name_to_hierarchy = {name_to_hierarchy}
+# identifier = "{visual_identifier}"
+# get_visual_cues(name_to_hierarchy, identifier)
+# '''
+
+#         output, error = run_code(all_code)
+#         log.append({
+#             "code": new_code,
+#             "output": output,
+#             "error": error,
+#             "concatenated_code": all_code,
+#             'num_tokens': (input_token, output_token),
+#             'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
+#         })
+
+#         if error is None:
+#             return log
         
-        if attempt < num_retries:
-            print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
-            prompt = error
-    return log
-
-def gen_layout_parallel(agent, prompt, num_retries, existing_code='', slide_width=0, slide_height=0, tmp_name='tmp'):
-    if existing_code == '':
-        existing_code = utils_functions
+#         if attempt < num_retries:
+#             print(f"Retrying... Attempt {attempt + 1} of {num_retries}")
+#             prompt = error
+#     return log
+
+# def gen_layout_parallel(agent, prompt, num_retries, existing_code='', slide_width=0, slide_height=0, tmp_name='tmp'):
+#     if existing_code == '':
+#         existing_code = utils_functions
         
-    existing_code += f'''
-poster = create_poster(width_inch={slide_width}, height_inch={slide_height})
-slide = add_blank_slide(poster)
-save_presentation(poster, file_name="poster_{tmp_name}.pptx")
-'''
-    agent.reset()
-    log = []
-    cumulative_input_token, cumulative_output_token = 0, 0
-    for attempt in range(num_retries + 1):
-        response = agent.step(prompt)
-        input_token, output_token = account_token(response)
-        cumulative_input_token += input_token
-        cumulative_output_token += output_token
-        new_code = match_response(response)
-        all_code = existing_code + '\n' + new_code
-
-        output, error = run_code(all_code)
-        log.append({
-            "code": new_code,
-            "output": output,
-            "error": error,
-            "concatenated_code": all_code,
-            'num_tokens': (input_token, output_token),
-            'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
-        })
-        if output is None or output == '':
-            prompt = 'No object name printed.'
-            continue
-
-        if error is None:
-            return log
+#     existing_code += f'''
+# poster = create_poster(width_inch={slide_width}, height_inch={slide_height})
+# slide = add_blank_slide(poster)
+# save_presentation(poster, file_name="poster_{tmp_name}.pptx")
+# '''
+#     agent.reset()
+#     log = []
+#     cumulative_input_token, cumulative_output_token = 0, 0
+#     for attempt in range(num_retries + 1):
+#         response = agent.step(prompt)
+#         input_token, output_token = account_token(response)
+#         cumulative_input_token += input_token
+#         cumulative_output_token += output_token
+#         new_code = match_response(response)
+#         all_code = existing_code + '\n' + new_code
+
+#         output, error = run_code(all_code)
+#         log.append({
+#             "code": new_code,
+#             "output": output,
+#             "error": error,
+#             "concatenated_code": all_code,
+#             'num_tokens': (input_token, output_token),
+#             'cumulative_tokens': (cumulative_input_token, cumulative_output_token)
+#         })
+#         if output is None or output == '':
+#             prompt = 'No object name printed.'
+#             continue
+
+#         if error is None:
+#             return log
         
-        if attempt < num_retries:
-            # print(f"Retrying... Attempt {attempt + 1} of {num_retries}", flush=True)
-            prompt = error
-    return log
-
-def compute_bullet_length(textbox_content):
-    total = 0
-    for bullet in textbox_content:
-        for run in bullet['runs']:
-            total += len(run['text'])
-    return total
-
-def check_bounding_boxes(bboxes, overall_width, overall_height):
-    """
-    Given a dictionary 'bboxes' whose keys are bounding-box names and whose values are
-    dictionaries with keys 'left', 'top', 'width', and 'height' (all floats),
-    along with the overall canvas width and height, this function checks for:
-
-      1) An overlap between any two bounding boxes (it returns a tuple of their names).
-      2) A bounding box that extends beyond the overall width or height (it returns a tuple
-         containing just that bounding box's name).
-
-    It stops upon finding the first error:
-      - If an overlap is found first, it returns (name1, name2).
-      - Otherwise, if an overflow is found, it returns (name,).
-      - If nothing is wrong, it returns ().
-
-    Parameters:
-        bboxes (dict): e.g. {
-            "box1": {"left": 10.0, "top": 10.0, "width": 50.0, "height": 20.0},
-            "box2": {"left": 55.0, "top": 15.0, "width": 10.0, "height": 10.0},
-            ...
-        }
-        overall_width (float): The total width of the available space.
-        overall_height (float): The total height of the available space.
-
-    Returns:
-        tuple: Either (box1, box2) if an overlap is found,
-               (box,) if a bounding box overflows,
-               or () if no problem is found.
-    """
-
-    # Convert bboxes into a list of (name, left, top, width, height) for easier iteration.
-    box_list = []
-    for name, coords in bboxes.items():
-        left = coords["left"]
-        top = coords["top"]
-        width = coords["width"]
-        height = coords["height"]
-        box_list.append((name, left, top, width, height))
-
-    # Helper function to check overlap between two boxes
-    def boxes_overlap(box_a, box_b):
-        # Unpack bounding-box data
-        name_a, left_a, top_a, width_a, height_a = box_a
-        name_b, left_b, top_b, width_b, height_b = box_b
-
-        # Compute right and bottom coordinates
-        right_a = left_a + width_a
-        bottom_a = top_a + height_a
-        right_b = left_b + width_b
-        bottom_b = top_b + height_b
-
-        # Rectangles overlap if not separated along either x or y axis
-        # If one box is completely to the left or right or above or below the other,
-        # there's no overlap.
-        no_overlap = (right_a <= left_b or  # A is completely left of B
-                      right_b <= left_a or  # B is completely left of A
-                      bottom_a <= top_b or  # A is completely above B
-                      bottom_b <= top_a)    # B is completely above A
-        return not no_overlap
-
-    # 1) Check for overlap first
-    n = len(box_list)
-    for i in range(n):
-        for j in range(i + 1, n):
-            if boxes_overlap(box_list[i], box_list[j]):
-                return (box_list[i][0], box_list[j][0])  # Return names
-
-    # 2) Check for overflow
-    for name, left, top, width, height in box_list:
-        right = left + width
-        bottom = top + height
-
-        # If boundary is outside [0, overall_width] or [0, overall_height], it's an overflow
-        if (left < 0 or top < 0 or right > overall_width or bottom > overall_height):
-            return (name,)
-
-    # 3) If nothing is wrong, return empty tuple
-    return ()
-
-
-def is_poster_filled(
-    bounding_boxes: dict,
-    overall_width: float,
-    overall_height: float,
-    max_lr_margin: float,
-    max_tb_margin: float
-) -> bool:
-    """
-    Given a dictionary of bounding boxes (keys are box names and
-    values are dicts with float keys: "left", "top", "width", "height"),
-    along with the overall dimensions of the poster and maximum allowed
-    margins, this function determines whether the boxes collectively
-    fill the poster within those margin constraints.
-
-    :param bounding_boxes: Dictionary of bounding boxes of the form:
-                          {
-                              "box1": {"left": float, "top": float, "width": float, "height": float},
-                              "box2": {...},
-                              ...
-                          }
-    :param overall_width: Total width of the poster
-    :param overall_height: Total height of the poster
-    :param max_lr_margin: Maximum allowed left and right margins
-    :param max_tb_margin: Maximum allowed top and bottom margins
-    :return: True if the bounding boxes fill the poster (with no big leftover spaces),
-             False otherwise.
-    """
-
-    # If there are no bounding boxes, we consider the poster unfilled.
-    if not bounding_boxes:
-        return False
-
-    # Extract the minimum left, maximum right, minimum top, and maximum bottom from all bounding boxes.
-    min_left = min(b["left"] for b in bounding_boxes.values())
-    max_right = max(b["left"] + b["width"] for b in bounding_boxes.values())
-    min_top = min(b["top"] for b in bounding_boxes.values())
-    max_bottom = max(b["top"] + b["height"] for b in bounding_boxes.values())
-
-    # Calculate leftover margins.
-    leftover_left = min_left
-    leftover_right = overall_width - max_right
-    leftover_top = min_top
-    leftover_bottom = overall_height - max_bottom
-
-    # Check if leftover margins exceed the allowed maxima.
-    if (leftover_left > max_lr_margin or leftover_right > max_lr_margin or
-        leftover_top > max_tb_margin or leftover_bottom > max_tb_margin):
-        return False
-
-    return True
-
-def check_and_fix_subsections(section, subsections):
-    """
-    Given a 'section' bounding box and a dictionary of 'subsections',
-    checks:
-
-    1) That each subsection is within the main section and that
-       no two subsections overlap.
-       - If there is a problem, returns a tuple of the names of
-         the offending subsections.
-
-    2) That the subsections fully occupy the area of 'section'.
-       - If not, greedily expand each subsection (in the order
-         left->right->top->bottom), and return a dictionary of
-         the updated bounding boxes for the subsections.
-
-    3) Otherwise, returns an empty tuple if nothing is wrong.
-
-    :param section: dict with keys "left", "top", "width", "height".
-    :param subsections: dict mapping name -> dict with "left", "top", "width", "height".
-    :return: Either
-        - tuple of subsection names that are out of bounds or overlapping,
-        - dict of expanded bounding boxes if they do not fully occupy 'section',
-        - or an empty tuple if everything is correct.
-    """
-
-    # --- Utility functions ---
-    def right(rect):
-        return rect["left"] + rect["width"]
-
-    def bottom(rect):
-        return rect["top"] + rect["height"]
-
-    def is_overlapping(r1, r2):
-        """
-        Returns True if rectangles r1 and r2 overlap (strictly),
-        False otherwise.
-        """
-        return not (
-            right(r1) <= r2["left"]
-            or r1["left"] >= right(r2)
-            or bottom(r1) <= r2["top"]
-            or r1["top"] >= bottom(r2)
-        )
-
-    # 1) Check each subsection is within the main section
-    names_violating = set()
-    sec_left, sec_top = section["left"], section["top"]
-    sec_right = section["left"] + section["width"]
-    sec_bottom = section["top"] + section["height"]
-
-    for name, sub in subsections.items():
-        # Check boundary
-        sub_left, sub_top = sub["left"], sub["top"]
-        sub_right, sub_bottom = right(sub), bottom(sub)
-        if (
-            sub_left < sec_left
-            or sub_top < sec_top
-            or sub_right > sec_right
-            or sub_bottom > sec_bottom
-        ):
-            # Out of bounds
-            names_violating.add(name)
-
-    # 2) Check pairwise overlaps
-    sub_keys = list(subsections.keys())
-    for i in range(len(sub_keys)):
-        for j in range(i + 1, len(sub_keys)):
-            n1, n2 = sub_keys[i], sub_keys[j]
-            if is_overlapping(subsections[n1], subsections[n2]):
-                # Mark both as violating
-                names_violating.add(n1)
-                names_violating.add(n2)
-
-    # If anything violated boundaries or overlapped, return them as a tuple
-    if names_violating:
-        return tuple(sorted(names_violating))
-
-    # 3) Check if subsections fully occupy the section by area.
-    #    (Since we've checked there's no overlap, area-based check is safe for "full coverage".)
-    area_section = section["width"] * section["height"]
-    area_subs = sum(
-        sub["width"] * sub["height"] for sub in subsections.values()
-    )
-
-    if area_subs < area_section:
-        # -- We need to expand subsections greedily. --
-
-        # Make a copy of the bounding boxes so as not to modify originals.
-        expanded_subs = {
-            name: {
-                "left": sub["left"],
-                "top": sub["top"],
-                "width": sub["width"],
-                "height": sub["height"],
-            }
-            for name, sub in subsections.items()
-        }
-
-        # Helper to see whether we are touching a boundary or another subsection
-        def touching_left(sname, sbox):
-            if abs(sbox["left"] - sec_left) < 1e-9:
-                # touches main section left boundary
-                return True
-            # touches the right edge of another subsection
-            for oname, obox in expanded_subs.items():
-                if oname == sname:
-                    continue
-                if abs(right(obox) - sbox["left"]) < 1e-9:
-                    return True
-            return False
-
-        def touching_right(sname, sbox):
-            r = right(sbox)
-            if abs(r - sec_right) < 1e-9:
-                return True
-            for oname, obox in expanded_subs.items():
-                if oname == sname:
-                    continue
-                if abs(obox["left"] - r) < 1e-9:
-                    return True
-            return False
-
-        def touching_top(sname, sbox):
-            if abs(sbox["top"] - sec_top) < 1e-9:
-                return True
-            for oname, obox in expanded_subs.items():
-                if oname == sname:
-                    continue
-                if abs(bottom(obox) - sbox["top"]) < 1e-9:
-                    return True
-            return False
-
-        def touching_bottom(sname, sbox):
-            b = bottom(sbox)
-            if abs(b - sec_bottom) < 1e-9:
-                return True
-            for oname, obox in expanded_subs.items():
-                if oname == sname:
-                    continue
-                if abs(obox["top"] - b) < 1e-9:
-                    return True
-            return False
-
-        # Attempt a single pass of expansions, left->right->top->bottom
-        for name in expanded_subs:
-            sub = expanded_subs[name]
-
-            # Expand left if not touching left boundary or another box
-            if not touching_left(name, sub):
-                # The "left boundary" is the maximum "right" of any subsection strictly to the left,
-                # or the section's left boundary, whichever is larger.
-                left_bound = sec_left
-                for oname, obox in expanded_subs.items():
-                    if oname == name:
-                        continue
-                    r_ = obox["left"] + obox["width"]
-                    # only consider those that are strictly left of this sub
-                    if r_ <= sub["left"] and r_ > left_bound:
-                        left_bound = r_
-                # Now expand
-                delta = sub["left"] - left_bound
-                if delta > 1e-9:  # If there's any real gap
-                    sub["width"] += delta
-                    sub["left"] = left_bound
-
-            # Expand right if not touching right boundary or another box
-            if not touching_right(name, sub):
-                right_bound = sec_right
-                sub_right = sub["left"] + sub["width"]
-                for oname, obox in expanded_subs.items():
-                    if oname == name:
-                        continue
-                    left_ = obox["left"]
-                    # only consider those that are strictly to the right
-                    if left_ >= sub_right and left_ < right_bound:
-                        right_bound = left_
-                delta = right_bound - (sub["left"] + sub["width"])
-                if delta > 1e-9:
-                    sub["width"] += delta
-
-            # Expand top if not touching top boundary or another box
-            if not touching_top(name, sub):
-                top_bound = sec_top
-                for oname, obox in expanded_subs.items():
-                    if oname == name:
-                        continue
-                    b_ = obox["top"] + obox["height"]
-                    if b_ <= sub["top"] and b_ > top_bound:
-                        top_bound = b_
-                delta = sub["top"] - top_bound
-                if delta > 1e-9:
-                    sub["height"] += delta
-                    sub["top"] = top_bound
-
-            # Expand bottom if not touching bottom boundary or another box
-            if not touching_bottom(name, sub):
-                bottom_bound = sec_bottom
-                sub_bottom = sub["top"] + sub["height"]
-                for oname, obox in expanded_subs.items():
-                    if oname == name:
-                        continue
-                    other_top = obox["top"]
-                    if other_top >= sub_bottom and other_top < bottom_bound:
-                        bottom_bound = other_top
-                delta = bottom_bound - (sub["top"] + sub["height"])
-                if delta > 1e-9:
-                    sub["height"] += delta
-
-        # After expansion, return the expanded dictionary
-        # per the spec: "If the second case happens, return a dictionary ...
-        # containing the modified bounding box dictionaries."
-        return expanded_subs
-
-    # If we get here, then area_subs == area_section and there's no overlap => all good
-    return ()
-
-async def rendered_dims(html: Path) -> tuple[int, int]:
-    async with async_playwright() as p:
-        browser = await p.chromium.launch()
-        page    = await browser.new_page()        # no fixed viewport yet
-        resolved = html.resolve()
-        # quote_from_bytes expects bytes, so we encode the path as UTF‐8:
-        url = "file://" + quote_from_bytes(str(resolved).encode("utf-8"), safe="/:")
-        await page.goto(url, wait_until="networkidle")
-
-        # 1) bounding-box of <body>
-        body_box = await page.eval_on_selector(
-            "body",
-            "el => el.getBoundingClientRect()")
-        w = int(body_box["width"])
-        h = int(body_box["height"])
-
-        await browser.close()
-        return w, h
+#         if attempt < num_retries:
+#             # print(f"Retrying... Attempt {attempt + 1} of {num_retries}", flush=True)
+#             prompt = error
+#     return log
+
+# def compute_bullet_length(textbox_content):
+#     total = 0
+#     for bullet in textbox_content:
+#         for run in bullet['runs']:
+#             total += len(run['text'])
+#     return total
+
+# def check_bounding_boxes(bboxes, overall_width, overall_height):
+#     """
+#     Given a dictionary 'bboxes' whose keys are bounding-box names and whose values are
+#     dictionaries with keys 'left', 'top', 'width', and 'height' (all floats),
+#     along with the overall canvas width and height, this function checks for:
+
+#       1) An overlap between any two bounding boxes (it returns a tuple of their names).
+#       2) A bounding box that extends beyond the overall width or height (it returns a tuple
+#          containing just that bounding box's name).
+
+#     It stops upon finding the first error:
+#       - If an overlap is found first, it returns (name1, name2).
+#       - Otherwise, if an overflow is found, it returns (name,).
+#       - If nothing is wrong, it returns ().
+
+#     Parameters:
+#         bboxes (dict): e.g. {
+#             "box1": {"left": 10.0, "top": 10.0, "width": 50.0, "height": 20.0},
+#             "box2": {"left": 55.0, "top": 15.0, "width": 10.0, "height": 10.0},
+#             ...
+#         }
+#         overall_width (float): The total width of the available space.
+#         overall_height (float): The total height of the available space.
+
+#     Returns:
+#         tuple: Either (box1, box2) if an overlap is found,
+#                (box,) if a bounding box overflows,
+#                or () if no problem is found.
+#     """
+
+#     # Convert bboxes into a list of (name, left, top, width, height) for easier iteration.
+#     box_list = []
+#     for name, coords in bboxes.items():
+#         left = coords["left"]
+#         top = coords["top"]
+#         width = coords["width"]
+#         height = coords["height"]
+#         box_list.append((name, left, top, width, height))
+
+#     # Helper function to check overlap between two boxes
+#     def boxes_overlap(box_a, box_b):
+#         # Unpack bounding-box data
+#         name_a, left_a, top_a, width_a, height_a = box_a
+#         name_b, left_b, top_b, width_b, height_b = box_b
+
+#         # Compute right and bottom coordinates
+#         right_a = left_a + width_a
+#         bottom_a = top_a + height_a
+#         right_b = left_b + width_b
+#         bottom_b = top_b + height_b
+
+#         # Rectangles overlap if not separated along either x or y axis
+#         # If one box is completely to the left or right or above or below the other,
+#         # there's no overlap.
+#         no_overlap = (right_a <= left_b or  # A is completely left of B
+#                       right_b <= left_a or  # B is completely left of A
+#                       bottom_a <= top_b or  # A is completely above B
+#                       bottom_b <= top_a)    # B is completely above A
+#         return not no_overlap
+
+#     # 1) Check for overlap first
+#     n = len(box_list)
+#     for i in range(n):
+#         for j in range(i + 1, n):
+#             if boxes_overlap(box_list[i], box_list[j]):
+#                 return (box_list[i][0], box_list[j][0])  # Return names
+
+#     # 2) Check for overflow
+#     for name, left, top, width, height in box_list:
+#         right = left + width
+#         bottom = top + height
+
+#         # If boundary is outside [0, overall_width] or [0, overall_height], it's an overflow
+#         if (left < 0 or top < 0 or right > overall_width or bottom > overall_height):
+#             return (name,)
+
+#     # 3) If nothing is wrong, return empty tuple
+#     return ()
+
+
+# def is_poster_filled(
+#     bounding_boxes: dict,
+#     overall_width: float,
+#     overall_height: float,
+#     max_lr_margin: float,
+#     max_tb_margin: float
+# ) -> bool:
+#     """
+#     Given a dictionary of bounding boxes (keys are box names and
+#     values are dicts with float keys: "left", "top", "width", "height"),
+#     along with the overall dimensions of the poster and maximum allowed
+#     margins, this function determines whether the boxes collectively
+#     fill the poster within those margin constraints.
+
+#     :param bounding_boxes: Dictionary of bounding boxes of the form:
+#                           {
+#                               "box1": {"left": float, "top": float, "width": float, "height": float},
+#                               "box2": {...},
+#                               ...
+#                           }
+#     :param overall_width: Total width of the poster
+#     :param overall_height: Total height of the poster
+#     :param max_lr_margin: Maximum allowed left and right margins
+#     :param max_tb_margin: Maximum allowed top and bottom margins
+#     :return: True if the bounding boxes fill the poster (with no big leftover spaces),
+#              False otherwise.
+#     """
+
+#     # If there are no bounding boxes, we consider the poster unfilled.
+#     if not bounding_boxes:
+#         return False
+
+#     # Extract the minimum left, maximum right, minimum top, and maximum bottom from all bounding boxes.
+#     min_left = min(b["left"] for b in bounding_boxes.values())
+#     max_right = max(b["left"] + b["width"] for b in bounding_boxes.values())
+#     min_top = min(b["top"] for b in bounding_boxes.values())
+#     max_bottom = max(b["top"] + b["height"] for b in bounding_boxes.values())
+
+#     # Calculate leftover margins.
+#     leftover_left = min_left
+#     leftover_right = overall_width - max_right
+#     leftover_top = min_top
+#     leftover_bottom = overall_height - max_bottom
+
+#     # Check if leftover margins exceed the allowed maxima.
+#     if (leftover_left > max_lr_margin or leftover_right > max_lr_margin or
+#         leftover_top > max_tb_margin or leftover_bottom > max_tb_margin):
+#         return False
+
+#     return True
+
+# def check_and_fix_subsections(section, subsections):
+#     """
+#     Given a 'section' bounding box and a dictionary of 'subsections',
+#     checks:
+
+#     1) That each subsection is within the main section and that
+#        no two subsections overlap.
+#        - If there is a problem, returns a tuple of the names of
+#          the offending subsections.
+
+#     2) That the subsections fully occupy the area of 'section'.
+#        - If not, greedily expand each subsection (in the order
+#          left->right->top->bottom), and return a dictionary of
+#          the updated bounding boxes for the subsections.
+
+#     3) Otherwise, returns an empty tuple if nothing is wrong.
+
+#     :param section: dict with keys "left", "top", "width", "height".
+#     :param subsections: dict mapping name -> dict with "left", "top", "width", "height".
+#     :return: Either
+#         - tuple of subsection names that are out of bounds or overlapping,
+#         - dict of expanded bounding boxes if they do not fully occupy 'section',
+#         - or an empty tuple if everything is correct.
+#     """
+
+#     # --- Utility functions ---
+#     def right(rect):
+#         return rect["left"] + rect["width"]
+
+#     def bottom(rect):
+#         return rect["top"] + rect["height"]
+
+#     def is_overlapping(r1, r2):
+#         """
+#         Returns True if rectangles r1 and r2 overlap (strictly),
+#         False otherwise.
+#         """
+#         return not (
+#             right(r1) <= r2["left"]
+#             or r1["left"] >= right(r2)
+#             or bottom(r1) <= r2["top"]
+#             or r1["top"] >= bottom(r2)
+#         )
+
+#     # 1) Check each subsection is within the main section
+#     names_violating = set()
+#     sec_left, sec_top = section["left"], section["top"]
+#     sec_right = section["left"] + section["width"]
+#     sec_bottom = section["top"] + section["height"]
+
+#     for name, sub in subsections.items():
+#         # Check boundary
+#         sub_left, sub_top = sub["left"], sub["top"]
+#         sub_right, sub_bottom = right(sub), bottom(sub)
+#         if (
+#             sub_left < sec_left
+#             or sub_top < sec_top
+#             or sub_right > sec_right
+#             or sub_bottom > sec_bottom
+#         ):
+#             # Out of bounds
+#             names_violating.add(name)
+
+#     # 2) Check pairwise overlaps
+#     sub_keys = list(subsections.keys())
+#     for i in range(len(sub_keys)):
+#         for j in range(i + 1, len(sub_keys)):
+#             n1, n2 = sub_keys[i], sub_keys[j]
+#             if is_overlapping(subsections[n1], subsections[n2]):
+#                 # Mark both as violating
+#                 names_violating.add(n1)
+#                 names_violating.add(n2)
+
+#     # If anything violated boundaries or overlapped, return them as a tuple
+#     if names_violating:
+#         return tuple(sorted(names_violating))
+
+#     # 3) Check if subsections fully occupy the section by area.
+#     #    (Since we've checked there's no overlap, area-based check is safe for "full coverage".)
+#     area_section = section["width"] * section["height"]
+#     area_subs = sum(
+#         sub["width"] * sub["height"] for sub in subsections.values()
+#     )
+
+#     if area_subs < area_section:
+#         # -- We need to expand subsections greedily. --
+
+#         # Make a copy of the bounding boxes so as not to modify originals.
+#         expanded_subs = {
+#             name: {
+#                 "left": sub["left"],
+#                 "top": sub["top"],
+#                 "width": sub["width"],
+#                 "height": sub["height"],
+#             }
+#             for name, sub in subsections.items()
+#         }
+
+#         # Helper to see whether we are touching a boundary or another subsection
+#         def touching_left(sname, sbox):
+#             if abs(sbox["left"] - sec_left) < 1e-9:
+#                 # touches main section left boundary
+#                 return True
+#             # touches the right edge of another subsection
+#             for oname, obox in expanded_subs.items():
+#                 if oname == sname:
+#                     continue
+#                 if abs(right(obox) - sbox["left"]) < 1e-9:
+#                     return True
+#             return False
+
+#         def touching_right(sname, sbox):
+#             r = right(sbox)
+#             if abs(r - sec_right) < 1e-9:
+#                 return True
+#             for oname, obox in expanded_subs.items():
+#                 if oname == sname:
+#                     continue
+#                 if abs(obox["left"] - r) < 1e-9:
+#                     return True
+#             return False
+
+#         def touching_top(sname, sbox):
+#             if abs(sbox["top"] - sec_top) < 1e-9:
+#                 return True
+#             for oname, obox in expanded_subs.items():
+#                 if oname == sname:
+#                     continue
+#                 if abs(bottom(obox) - sbox["top"]) < 1e-9:
+#                     return True
+#             return False
+
+#         def touching_bottom(sname, sbox):
+#             b = bottom(sbox)
+#             if abs(b - sec_bottom) < 1e-9:
+#                 return True
+#             for oname, obox in expanded_subs.items():
+#                 if oname == sname:
+#                     continue
+#                 if abs(obox["top"] - b) < 1e-9:
+#                     return True
+#             return False
+
+#         # Attempt a single pass of expansions, left->right->top->bottom
+#         for name in expanded_subs:
+#             sub = expanded_subs[name]
+
+#             # Expand left if not touching left boundary or another box
+#             if not touching_left(name, sub):
+#                 # The "left boundary" is the maximum "right" of any subsection strictly to the left,
+#                 # or the section's left boundary, whichever is larger.
+#                 left_bound = sec_left
+#                 for oname, obox in expanded_subs.items():
+#                     if oname == name:
+#                         continue
+#                     r_ = obox["left"] + obox["width"]
+#                     # only consider those that are strictly left of this sub
+#                     if r_ <= sub["left"] and r_ > left_bound:
+#                         left_bound = r_
+#                 # Now expand
+#                 delta = sub["left"] - left_bound
+#                 if delta > 1e-9:  # If there's any real gap
+#                     sub["width"] += delta
+#                     sub["left"] = left_bound
+
+#             # Expand right if not touching right boundary or another box
+#             if not touching_right(name, sub):
+#                 right_bound = sec_right
+#                 sub_right = sub["left"] + sub["width"]
+#                 for oname, obox in expanded_subs.items():
+#                     if oname == name:
+#                         continue
+#                     left_ = obox["left"]
+#                     # only consider those that are strictly to the right
+#                     if left_ >= sub_right and left_ < right_bound:
+#                         right_bound = left_
+#                 delta = right_bound - (sub["left"] + sub["width"])
+#                 if delta > 1e-9:
+#                     sub["width"] += delta
+
+#             # Expand top if not touching top boundary or another box
+#             if not touching_top(name, sub):
+#                 top_bound = sec_top
+#                 for oname, obox in expanded_subs.items():
+#                     if oname == name:
+#                         continue
+#                     b_ = obox["top"] + obox["height"]
+#                     if b_ <= sub["top"] and b_ > top_bound:
+#                         top_bound = b_
+#                 delta = sub["top"] - top_bound
+#                 if delta > 1e-9:
+#                     sub["height"] += delta
+#                     sub["top"] = top_bound
+
+#             # Expand bottom if not touching bottom boundary or another box
+#             if not touching_bottom(name, sub):
+#                 bottom_bound = sec_bottom
+#                 sub_bottom = sub["top"] + sub["height"]
+#                 for oname, obox in expanded_subs.items():
+#                     if oname == name:
+#                         continue
+#                     other_top = obox["top"]
+#                     if other_top >= sub_bottom and other_top < bottom_bound:
+#                         bottom_bound = other_top
+#                 delta = bottom_bound - (sub["top"] + sub["height"])
+#                 if delta > 1e-9:
+#                     sub["height"] += delta
+
+#         # After expansion, return the expanded dictionary
+#         # per the spec: "If the second case happens, return a dictionary ...
+#         # containing the modified bounding box dictionaries."
+#         return expanded_subs
+
+#     # If we get here, then area_subs == area_section and there's no overlap => all good
+#     return ()
+
+# async def rendered_dims(html: Path) -> tuple[int, int]:
+#     async with async_playwright() as p:
+#         browser = await p.chromium.launch()
+#         page    = await browser.new_page()        # no fixed viewport yet
+#         resolved = html.resolve()
+#         # quote_from_bytes expects bytes, so we encode the path as UTF‐8:
+#         url = "file://" + quote_from_bytes(str(resolved).encode("utf-8"), safe="/:")
+#         await page.goto(url, wait_until="networkidle")
+
+#         # 1) bounding-box of <body>
+#         body_box = await page.eval_on_selector(
+#             "body",
+#             "el => el.getBoundingClientRect()")
+#         w = int(body_box["width"])
+#         h = int(body_box["height"])
+
+#         await browser.close()
+#         return w, h
 
     
-def html_to_png(html_abs_path, poster_width_default, poster_height_default, output_path):
-    html_file = html_abs_path
+# def html_to_png(html_abs_path, poster_width_default, poster_height_default, output_path):
+#     html_file = html_abs_path
 
-    try:
-        w, h = asyncio.run(rendered_dims(html_file))
-    except:
-        w = poster_width_default
-        h = poster_height_default
+#     try:
+#         w, h = asyncio.run(rendered_dims(html_file))
+#     except:
+#         w = poster_width_default
+#         h = poster_height_default
 
-    with sync_playwright() as p:
-        path_posix = Path(html_file).resolve().as_posix()
+#     with sync_playwright() as p:
+#         path_posix = Path(html_file).resolve().as_posix()
 
-        file_url = "file://" + quote(path_posix, safe="/:")
-        browser = p.chromium.launch()
-        page    = browser.new_page(viewport={"width": w, "height": h})
-        page.goto(file_url, wait_until='networkidle')
-        page.screenshot(path=output_path, full_page=True)
-        browser.close()
+#         file_url = "file://" + quote(path_posix, safe="/:")
+#         browser = p.chromium.launch()
+#         page    = browser.new_page(viewport={"width": w, "height": h})
+#         page.goto(file_url, wait_until='networkidle')
+#         page.screenshot(path=output_path, full_page=True)
+#         browser.close()
 
-def account_token(response):
-    input_token = response.info['usage']['prompt_tokens']
-    output_token = response.info['usage']['completion_tokens']
+# def account_token(response):
+#     input_token = response.info['usage']['prompt_tokens']
+#     output_token = response.info['usage']['completion_tokens']
 
-    return input_token, output_token
+#     return input_token, output_token
 
-def style_bullet_content(bullet_content_item, color, fill_color):
-    for i in range(len(bullet_content_item)):
-        bullet_content_item[i]['runs'][0]['color'] = color
-        bullet_content_item[i]['runs'][0]['fill_color'] = fill_color
+# def style_bullet_content(bullet_content_item, color, fill_color):
+#     for i in range(len(bullet_content_item)):
+#         bullet_content_item[i]['runs'][0]['color'] = color
+#         bullet_content_item[i]['runs'][0]['fill_color'] = fill_color
 
 def scale_to_target_area(width, height, target_width=900, target_height=1200):
     """
@@ -1016,334 +1016,334 @@ def scale_to_target_area(width, height, target_width=900, target_height=1200):
     # Optional: Round the dimensions to integers.
     return int(round(new_width)), int(round(new_height))
 
-def char_capacity(
-    bbox,
-    font_size_px=40 * (96 / 72),  # Default font size in px (40pt converted to px)
-    *,
-    # Average glyph width as fraction of font-size (≈0.6 for monospace,
-    # ≈0.52–0.55 for most proportional sans-serif faces)
-    avg_width_ratio: float = 0.54,
-    line_height_ratio: float = 1,
-    # Optional inner padding in px that the renderer might reserve
-    padding_px: int = 0,
-) -> int:
-    """
-    Estimate the number of characters that will fit into a rectangular text box.
-
-    Parameters
-    ----------
-    bbox : (x, y, height, width)  # all in pixels
-    font_size_px : int           # font size in px
-    avg_width_ratio : float      # average char width ÷ fontSize
-    line_height_ratio : float    # line height ÷ fontSize
-    padding_px : int             # optional inner padding on each side
-
-    Returns
-    -------
-    int : estimated character capacity
-    """
-    CHAR_CONST = 10
-    _, _, height_px, width_px = bbox
-
-    usable_w = max(0, width_px - 2 * padding_px)
-    usable_h = max(0, height_px - 2 * padding_px)
-
-    if usable_w == 0 or usable_h == 0:
-        return 0  # box is too small
-
-    avg_char_w = font_size_px * avg_width_ratio
-    line_height = font_size_px * line_height_ratio
-
-    chars_per_line = max(1, math.floor(usable_w / avg_char_w))
-    lines = max(1, math.floor(usable_h / line_height))
-
-    return chars_per_line * lines * CHAR_CONST
-
-def estimate_characters(width_in_inches, height_in_inches, font_size_points, line_spacing_points=None):
-    """
-    Estimate the number of characters that can fit into a bounding box.
-
-    :param width_in_inches:  The width of the bounding box, in inches.
-    :param height_in_inches: The height of the bounding box, in inches.
-    :param font_size_points: The font size, in points.
-    :param line_spacing_points: (Optional) The line spacing, in points.
-                                Defaults to 1.5 × font_size_points if not provided.
-    :return: Estimated number of characters that fit in the bounding box.
-    """
-    if line_spacing_points is None:
-        # Default line spacing is 1.5 times the font size
-        line_spacing_points = 1.5 * font_size_points
-
-    # 1 inch = 72 points 
-    width_in_points = width_in_inches * 72
-    height_in_points = height_in_inches * 72
-
-    # Rough approximation of the average width of a character: half of the font size
-    avg_char_width = 0.5 * font_size_points
-
-    # Number of characters that can fit per line
-    chars_per_line = int(width_in_points // avg_char_width)
-
-    # Number of lines that can fit in the bounding box
-    lines_count = int(height_in_points // line_spacing_points)
-
-    # Total number of characters
-    total_characters = chars_per_line * lines_count
-
-    return total_characters
-
-def equivalent_length_with_forced_breaks(text, width_in_inches, font_size_points):
-    """
-    Returns the "width-equivalent length" of the text when forced newlines
-    are respected. Each physical line (including partial) is counted as if it
-    had 'max_chars_per_line' characters.
+# def char_capacity(
+#     bbox,
+#     font_size_px=40 * (96 / 72),  # Default font size in px (40pt converted to px)
+#     *,
+#     # Average glyph width as fraction of font-size (≈0.6 for monospace,
+#     # ≈0.52–0.55 for most proportional sans-serif faces)
+#     avg_width_ratio: float = 0.54,
+#     line_height_ratio: float = 1,
+#     # Optional inner padding in px that the renderer might reserve
+#     padding_px: int = 0,
+# ) -> int:
+#     """
+#     Estimate the number of characters that will fit into a rectangular text box.
+
+#     Parameters
+#     ----------
+#     bbox : (x, y, height, width)  # all in pixels
+#     font_size_px : int           # font size in px
+#     avg_width_ratio : float      # average char width ÷ fontSize
+#     line_height_ratio : float    # line height ÷ fontSize
+#     padding_px : int             # optional inner padding on each side
+
+#     Returns
+#     -------
+#     int : estimated character capacity
+#     """
+#     CHAR_CONST = 10
+#     _, _, height_px, width_px = bbox
+
+#     usable_w = max(0, width_px - 2 * padding_px)
+#     usable_h = max(0, height_px - 2 * padding_px)
+
+#     if usable_w == 0 or usable_h == 0:
+#         return 0  # box is too small
+
+#     avg_char_w = font_size_px * avg_width_ratio
+#     line_height = font_size_px * line_height_ratio
+
+#     chars_per_line = max(1, math.floor(usable_w / avg_char_w))
+#     lines = max(1, math.floor(usable_h / line_height))
+
+#     return chars_per_line * lines * CHAR_CONST
+
+# def estimate_characters(width_in_inches, height_in_inches, font_size_points, line_spacing_points=None):
+#     """
+#     Estimate the number of characters that can fit into a bounding box.
+
+#     :param width_in_inches:  The width of the bounding box, in inches.
+#     :param height_in_inches: The height of the bounding box, in inches.
+#     :param font_size_points: The font size, in points.
+#     :param line_spacing_points: (Optional) The line spacing, in points.
+#                                 Defaults to 1.5 × font_size_points if not provided.
+#     :return: Estimated number of characters that fit in the bounding box.
+#     """
+#     if line_spacing_points is None:
+#         # Default line spacing is 1.5 times the font size
+#         line_spacing_points = 1.5 * font_size_points
+
+#     # 1 inch = 72 points 
+#     width_in_points = width_in_inches * 72
+#     height_in_points = height_in_inches * 72
+
+#     # Rough approximation of the average width of a character: half of the font size
+#     avg_char_width = 0.5 * font_size_points
+
+#     # Number of characters that can fit per line
+#     chars_per_line = int(width_in_points // avg_char_width)
+
+#     # Number of lines that can fit in the bounding box
+#     lines_count = int(height_in_points // line_spacing_points)
+
+#     # Total number of characters
+#     total_characters = chars_per_line * lines_count
+
+#     return total_characters
+
+# def equivalent_length_with_forced_breaks(text, width_in_inches, font_size_points):
+#     """
+#     Returns the "width-equivalent length" of the text when forced newlines
+#     are respected. Each physical line (including partial) is counted as if it
+#     had 'max_chars_per_line' characters.
     
-    This number can exceed len(text), because forced newlines waste leftover
-    space on the line.
-    """
-    # 1 inch = 72 points
-    width_in_points = width_in_inches * 72
-    avg_char_width = 0.5 * font_size_points
-
-    # How many characters fit in one fully occupied line?
-    max_chars_per_line = int(width_in_points // avg_char_width)
-
-    # Split on explicit newlines
-    logical_lines = text.split('\n')
-
-    total_equiv_length = 0
-
-    for line in logical_lines:
-        # If the line is empty, we still "use" one line (which is max_chars_per_line slots).
-        if not line:
-            total_equiv_length += max_chars_per_line
-            continue
-
-        line_length = len(line)
-        # How many sub-lines (wraps) does it need?
-        sub_lines = math.ceil(line_length / max_chars_per_line)
-
-        # Each sub-line is effectively counted as if it were fully used
-        total_equiv_length += sub_lines * max_chars_per_line
-
-    return total_equiv_length
-
-def actual_rendered_length(
-    text,
-    width_in_inches,
-    height_in_inches,
-    font_size_points,
-    line_spacing_points=None
-):
-    """
-    Estimate how many characters from `text` will actually fit in the bounding
-    box, taking into account explicit newlines.
-    """
-    if line_spacing_points is None:
-        line_spacing_points = 1.5 * font_size_points
-
-    # 1 inch = 72 points
-    width_in_points = width_in_inches * 72
-    height_in_points = height_in_inches * 72
-
-    # Estimate average character width
-    avg_char_width = 0.5 * font_size_points
-
-    # Maximum chars per line (approx)
-    max_chars_per_line = int(width_in_points // avg_char_width)
-
-    # Maximum number of lines that can fit
-    max_lines = int(height_in_points // line_spacing_points)
-
-    # Split on newline chars to get individual "logical" lines
-    logical_lines = text.split('\n')
-
-    used_lines = 0
-    displayed_chars = 0
-
-    for line in logical_lines:
-        # If the line is empty, it still takes one printed line
-        if not line:
-            used_lines += 1
-            # Stop if we exceed available lines
-            if used_lines >= max_lines:
-                break
-            continue
-
-        # Number of sub-lines the text will occupy if it wraps
-        sub_lines = math.ceil(len(line) / max_chars_per_line)
-
-        # If we don't exceed the bounding box's vertical capacity
-        if used_lines + sub_lines <= max_lines:
-            # All chars fit within the bounding box
-            displayed_chars += len(line)
-            used_lines += sub_lines
-        else:
-            # Only part of this line will fit
-            lines_left = max_lines - used_lines
-            if lines_left <= 0:
-                # No space left at all
-                break
-
-            # We can render only `lines_left` sub-lines of this line
-            # That means we can render up to:
-            chars_that_fit = lines_left * max_chars_per_line
-
-            # Clip to the actual number of characters
-            chars_that_fit = min(chars_that_fit, len(line))
-
-            displayed_chars += chars_that_fit
-            used_lines += lines_left  # We've used up all remaining lines
-            break  # No more space in the bounding box
-
-    return displayed_chars
-
-
-def remove_hierarchy_and_id(data):
-    """
-    Recursively remove the 'hierarchy' and 'id' fields from a nested
-    dictionary representing sections and subsections.
-    """
-    if isinstance(data, dict):
-        # Create a new dict to store filtered data
-        new_data = {}
-        for key, value in data.items():
-            # Skip the keys "hierarchy" and "id"
-            if key in ("hierarchy", "id", 'location'):
-                continue
-            # Recursively process the value
-            new_data[key] = remove_hierarchy_and_id(value)
-        return new_data
-    elif isinstance(data, list):
-        # If it's a list, process each item recursively
-        return [remove_hierarchy_and_id(item) for item in data]
-    else:
-        # Base case: if it's neither dict nor list, just return the value as is
-        return data
+#     This number can exceed len(text), because forced newlines waste leftover
+#     space on the line.
+#     """
+#     # 1 inch = 72 points
+#     width_in_points = width_in_inches * 72
+#     avg_char_width = 0.5 * font_size_points
+
+#     # How many characters fit in one fully occupied line?
+#     max_chars_per_line = int(width_in_points // avg_char_width)
+
+#     # Split on explicit newlines
+#     logical_lines = text.split('\n')
+
+#     total_equiv_length = 0
+
+#     for line in logical_lines:
+#         # If the line is empty, we still "use" one line (which is max_chars_per_line slots).
+#         if not line:
+#             total_equiv_length += max_chars_per_line
+#             continue
+
+#         line_length = len(line)
+#         # How many sub-lines (wraps) does it need?
+#         sub_lines = math.ceil(line_length / max_chars_per_line)
+
+#         # Each sub-line is effectively counted as if it were fully used
+#         total_equiv_length += sub_lines * max_chars_per_line
+
+#     return total_equiv_length
+
+# def actual_rendered_length(
+#     text,
+#     width_in_inches,
+#     height_in_inches,
+#     font_size_points,
+#     line_spacing_points=None
+# ):
+#     """
+#     Estimate how many characters from `text` will actually fit in the bounding
+#     box, taking into account explicit newlines.
+#     """
+#     if line_spacing_points is None:
+#         line_spacing_points = 1.5 * font_size_points
+
+#     # 1 inch = 72 points
+#     width_in_points = width_in_inches * 72
+#     height_in_points = height_in_inches * 72
+
+#     # Estimate average character width
+#     avg_char_width = 0.5 * font_size_points
+
+#     # Maximum chars per line (approx)
+#     max_chars_per_line = int(width_in_points // avg_char_width)
+
+#     # Maximum number of lines that can fit
+#     max_lines = int(height_in_points // line_spacing_points)
+
+#     # Split on newline chars to get individual "logical" lines
+#     logical_lines = text.split('\n')
+
+#     used_lines = 0
+#     displayed_chars = 0
+
+#     for line in logical_lines:
+#         # If the line is empty, it still takes one printed line
+#         if not line:
+#             used_lines += 1
+#             # Stop if we exceed available lines
+#             if used_lines >= max_lines:
+#                 break
+#             continue
+
+#         # Number of sub-lines the text will occupy if it wraps
+#         sub_lines = math.ceil(len(line) / max_chars_per_line)
+
+#         # If we don't exceed the bounding box's vertical capacity
+#         if used_lines + sub_lines <= max_lines:
+#             # All chars fit within the bounding box
+#             displayed_chars += len(line)
+#             used_lines += sub_lines
+#         else:
+#             # Only part of this line will fit
+#             lines_left = max_lines - used_lines
+#             if lines_left <= 0:
+#                 # No space left at all
+#                 break
+
+#             # We can render only `lines_left` sub-lines of this line
+#             # That means we can render up to:
+#             chars_that_fit = lines_left * max_chars_per_line
+
+#             # Clip to the actual number of characters
+#             chars_that_fit = min(chars_that_fit, len(line))
+
+#             displayed_chars += chars_that_fit
+#             used_lines += lines_left  # We've used up all remaining lines
+#             break  # No more space in the bounding box
+
+#     return displayed_chars
+
+
+# def remove_hierarchy_and_id(data):
+#     """
+#     Recursively remove the 'hierarchy' and 'id' fields from a nested
+#     dictionary representing sections and subsections.
+#     """
+#     if isinstance(data, dict):
+#         # Create a new dict to store filtered data
+#         new_data = {}
+#         for key, value in data.items():
+#             # Skip the keys "hierarchy" and "id"
+#             if key in ("hierarchy", "id", 'location'):
+#                 continue
+#             # Recursively process the value
+#             new_data[key] = remove_hierarchy_and_id(value)
+#         return new_data
+#     elif isinstance(data, list):
+#         # If it's a list, process each item recursively
+#         return [remove_hierarchy_and_id(item) for item in data]
+#     else:
+#         # Base case: if it's neither dict nor list, just return the value as is
+#         return data
     
-def outline_estimate_num_chars(outline):
-    for k, v in outline.items():
-        if k == 'meta':
-            continue
-        if 'title' in k.lower() or 'author' in k.lower() or 'reference' in k.lower():
-            continue
-        if not 'subsections' in v:
-            num_chars = estimate_characters(
-                v['location']['width'], 
-                v['location']['height'], 
-                60, line_spacing_points=None
-            )
-            v['num_chars'] = num_chars
-        else:
-            for k_sub, v_sub in v['subsections'].items():
-                if 'title' in k_sub.lower():
-                    continue
-                if 'path' in v_sub:
-                    continue
-                num_chars = estimate_characters(
-                    v_sub['location']['width'], 
-                    v_sub['location']['height'], 
-                    60, line_spacing_points=None
-                )
-                v_sub['num_chars'] = num_chars
-
-def generate_length_suggestions(result_json, original_section_outline, raw_section_outline):
-    NOT_CHANGE = 'Do not change text.'
-    original_section_outline = json.loads(original_section_outline)
-    suggestion_flag = False
-    new_section_outline = copy.deepcopy(result_json)
-    def check_length(text, target, width, height):
-        text_length = equivalent_length_with_forced_breaks(
-            text,
-            width,
-            font_size_points=60,
-        )
-        if text_length - target > 100:
-            return f'Text too long, shrink by {text_length - target} characters.'
-        elif target - text_length > 100:
-            return f'Text too short, expand by {target - text_length} characters.'
-        else:
-            return NOT_CHANGE
-
-    if 'num_chars' in original_section_outline:
-        new_section_outline['suggestions'] = check_length(
-            result_json['description'], 
-            original_section_outline['num_chars'],
-            raw_section_outline['location']['width'],
-            raw_section_outline['location']['height']
-        )
-        if new_section_outline['suggestions'] != NOT_CHANGE:
-            suggestion_flag = True
-    if 'subsections' in original_section_outline:
-        for k, v in original_section_outline['subsections'].items():
-            if 'num_chars' in v:
-                new_section_outline['subsections'][k]['suggestion'] = check_length(
-                    result_json['subsections'][k]['description'], 
-                    v['num_chars'],
-                    raw_section_outline['subsections'][k]['location']['width'],
-                    raw_section_outline['subsections'][k]['location']['height']
-                )
-                if new_section_outline['subsections'][k]['suggestion'] != NOT_CHANGE:
-                    suggestion_flag = True
-
-    return new_section_outline, suggestion_flag
-
-def get_img_ratio(img_path):
-    img = Image.open(img_path)
-    return {
-        'width': img.width,
-        'height': img.height
-    }
-
-def get_img_ratio_in_section(content_json):
-    res = {}
-    if 'path' in content_json:
-        res[content_json['path']] = get_img_ratio(content_json['path'])
-
-    if 'subsections' in content_json:
-        for subsection_name, val in content_json['subsections'].items():
-            if 'path' in val:
-                res[val['path']] = get_img_ratio(val['path'])
-
-    return res
-
-
-def get_snapshot_from_section(leaf_section, section_name, name_to_hierarchy, leaf_name, section_code, empty_poster_path='poster.pptx'):
-    hierarchy = name_to_hierarchy[leaf_name]
-    hierarchy_overflow_name = f'tmp/overflow_check_<{section_name}>_<{leaf_section}>_hierarchy_{hierarchy}'
-    run_code_with_utils(section_code, utils_functions)
-    poster = Presentation(empty_poster_path)
-    # add border regardless of the hierarchy
-    curr_location = add_border_hierarchy(
-        poster, 
-        name_to_hierarchy, 
-        hierarchy, 
-        border_width=10,
-        # regardless=True
-    )
-    if not leaf_section in curr_location:
-        leaf_section = section_name
-    save_presentation(poster, file_name=f"{hierarchy_overflow_name}.pptx")
-    ppt_to_images(
-        f"{hierarchy_overflow_name}.pptx", 
-        hierarchy_overflow_name, 
-        dpi=200
-    )
-    poster_image_path = os.path.join(f"{hierarchy_overflow_name}", "slide_0001.jpg")
-    poster_image = Image.open(poster_image_path)
-
-    poster_width = emu_to_inches(poster.slide_width)
-    poster_height = emu_to_inches(poster.slide_height)
-    locations = convert_pptx_bboxes_json_to_image_json(
-        curr_location, 
-        poster_width, 
-        poster_height
-    )
-    zoomed_in_img = zoom_in_image_by_bbox(
-        poster_image, 
-        locations[leaf_name], 
-        padding=0.01
-    )
-    # save the zoomed_in_img
-    zoomed_in_img.save(f"{hierarchy_overflow_name}_zoomed_in.jpg")
-    return curr_location, zoomed_in_img, f"{hierarchy_overflow_name}_zoomed_in.jpg"
+# def outline_estimate_num_chars(outline):
+#     for k, v in outline.items():
+#         if k == 'meta':
+#             continue
+#         if 'title' in k.lower() or 'author' in k.lower() or 'reference' in k.lower():
+#             continue
+#         if not 'subsections' in v:
+#             num_chars = estimate_characters(
+#                 v['location']['width'], 
+#                 v['location']['height'], 
+#                 60, line_spacing_points=None
+#             )
+#             v['num_chars'] = num_chars
+#         else:
+#             for k_sub, v_sub in v['subsections'].items():
+#                 if 'title' in k_sub.lower():
+#                     continue
+#                 if 'path' in v_sub:
+#                     continue
+#                 num_chars = estimate_characters(
+#                     v_sub['location']['width'], 
+#                     v_sub['location']['height'], 
+#                     60, line_spacing_points=None
+#                 )
+#                 v_sub['num_chars'] = num_chars
+
+# def generate_length_suggestions(result_json, original_section_outline, raw_section_outline):
+#     NOT_CHANGE = 'Do not change text.'
+#     original_section_outline = json.loads(original_section_outline)
+#     suggestion_flag = False
+#     new_section_outline = copy.deepcopy(result_json)
+#     def check_length(text, target, width, height):
+#         text_length = equivalent_length_with_forced_breaks(
+#             text,
+#             width,
+#             font_size_points=60,
+#         )
+#         if text_length - target > 100:
+#             return f'Text too long, shrink by {text_length - target} characters.'
+#         elif target - text_length > 100:
+#             return f'Text too short, expand by {target - text_length} characters.'
+#         else:
+#             return NOT_CHANGE
+
+#     if 'num_chars' in original_section_outline:
+#         new_section_outline['suggestions'] = check_length(
+#             result_json['description'], 
+#             original_section_outline['num_chars'],
+#             raw_section_outline['location']['width'],
+#             raw_section_outline['location']['height']
+#         )
+#         if new_section_outline['suggestions'] != NOT_CHANGE:
+#             suggestion_flag = True
+#     if 'subsections' in original_section_outline:
+#         for k, v in original_section_outline['subsections'].items():
+#             if 'num_chars' in v:
+#                 new_section_outline['subsections'][k]['suggestion'] = check_length(
+#                     result_json['subsections'][k]['description'], 
+#                     v['num_chars'],
+#                     raw_section_outline['subsections'][k]['location']['width'],
+#                     raw_section_outline['subsections'][k]['location']['height']
+#                 )
+#                 if new_section_outline['subsections'][k]['suggestion'] != NOT_CHANGE:
+#                     suggestion_flag = True
+
+#     return new_section_outline, suggestion_flag
+
+# def get_img_ratio(img_path):
+#     img = Image.open(img_path)
+#     return {
+#         'width': img.width,
+#         'height': img.height
+#     }
+
+# def get_img_ratio_in_section(content_json):
+#     res = {}
+#     if 'path' in content_json:
+#         res[content_json['path']] = get_img_ratio(content_json['path'])
+
+#     if 'subsections' in content_json:
+#         for subsection_name, val in content_json['subsections'].items():
+#             if 'path' in val:
+#                 res[val['path']] = get_img_ratio(val['path'])
+
+#     return res
+
+
+# def get_snapshot_from_section(leaf_section, section_name, name_to_hierarchy, leaf_name, section_code, empty_poster_path='poster.pptx'):
+#     hierarchy = name_to_hierarchy[leaf_name]
+#     hierarchy_overflow_name = f'tmp/overflow_check_<{section_name}>_<{leaf_section}>_hierarchy_{hierarchy}'
+#     run_code_with_utils(section_code, utils_functions)
+#     poster = Presentation(empty_poster_path)
+#     # add border regardless of the hierarchy
+#     curr_location = add_border_hierarchy(
+#         poster, 
+#         name_to_hierarchy, 
+#         hierarchy, 
+#         border_width=10,
+#         # regardless=True
+#     )
+#     if not leaf_section in curr_location:
+#         leaf_section = section_name
+#     save_presentation(poster, file_name=f"{hierarchy_overflow_name}.pptx")
+#     ppt_to_images(
+#         f"{hierarchy_overflow_name}.pptx", 
+#         hierarchy_overflow_name, 
+#         dpi=200
+#     )
+#     poster_image_path = os.path.join(f"{hierarchy_overflow_name}", "slide_0001.jpg")
+#     poster_image = Image.open(poster_image_path)
+
+#     poster_width = emu_to_inches(poster.slide_width)
+#     poster_height = emu_to_inches(poster.slide_height)
+#     locations = convert_pptx_bboxes_json_to_image_json(
+#         curr_location, 
+#         poster_width, 
+#         poster_height
+#     )
+#     zoomed_in_img = zoom_in_image_by_bbox(
+#         poster_image, 
+#         locations[leaf_name], 
+#         padding=0.01
+#     )
+#     # save the zoomed_in_img
+#     zoomed_in_img.save(f"{hierarchy_overflow_name}_zoomed_in.jpg")
+#     return curr_location, zoomed_in_img, f"{hierarchy_overflow_name}_zoomed_in.jpg"

app.py

@@ -151,8 +151,8 @@ iface = gr.Interface(
     ],
     title="📄 Paper2Poster",
     description=(
-        "Upload your paper, and the pipeline will automatically generate a fully compilable LaTeX poster; you can download the ZIP file and compile it yourself. Each paper takes approximately 6–10 minutes to process."
-        "Provide either an arXiv link or upload a PDF file (choose one); the system will generate a poster and package it for download."
+        "Upload your paper, and the pipeline will automatically generate a fully compilable LaTeX poster; you can download the ZIP file and compile it yourself. Each paper takes approximately 6–10 minutes to process.\n"
+        "Provide either an arXiv link or upload a PDF file (choose one); the system will generate a poster and package it for download.\n"
         "You must upload at least one institutional logo (multiple allowed).\n"
     ),
     allow_flagging="never",