update logo

src/modules/app.py

@@ -13,10 +13,12 @@ For more information, see
 - https://app.bitly.com/settings/api
 '''
 
-def calculate_positions(image_count, item_size=(20, 20), page_size=(91, 55), padding=(10, 10)):
-    positions = []
+def calculate_layout(image_count, item_size=(40, 40), page_size=(91, 55), position=(30, 67)):
+    layout = []
     x, y = 0, 0
-    pos_px, pos_py = padding
+    pos_px, pos_py = position
+    size_x, size_y = item_size
+    size_px, size_py = item_size
 
     for i in range(image_count):
         if x + item_size[0] > page_size[0]:  # Check for horizontal overflow
@@ -27,10 +29,10 @@ def calculate_positions(image_count, item_size=(20, 20), page_size=(91, 55), pad
             x = 0
             y = 0
 
-        positions.append((x, y, pos_px, pos_py))
+        layout.append((image_count, x, y, pos_px, pos_py, size_x, size_y, size_px, size_py))
         x += item_size[0] + pos_px
-    print(positions)
-    return positions
+    # print(layout)
+    return layout
 
 with gr.Blocks() as demo:
     gr.Markdown(description)
@@ -39,40 +41,37 @@ with gr.Blocks() as demo:
             access_token = gr.Textbox(label="Access Token", placeholder="***")
             api_url = gr.Textbox(label="API base URL", placeholder="https://")
             txt_input = gr.TextArea(label="Enter Text with URLs")
-            count_url = gr.Dropdown(visible=False)
+            count_url = gr.Dropdown(visible=False, allow_custom_value=True)
             @gr.render(inputs=[txt_input])
             def update_cnt(txt):
                 urls = re.findall(r'http[s]?://\S+', txt)
                 return urls
 
             with gr.Row():
-                shorten_checkbox = gr.Checkbox(label="Shorten URL", value=True)
+                shorten_checkbox = gr.Checkbox(label="Shorten URL", value=False)
                 qr_checkbox = gr.Checkbox(label="Generate QR Code", value=True)
-            submit_button = gr.Button("Process URLs", variant='primary')
+            with gr.Row():
+                clear_button = gr.ClearButton(txt_input)
+                submit_button = gr.Button("Process URLs", variant='primary')
 
             with gr.Accordion(open=False, label="Insert"):
                 with gr.Row():
-                    cm_img_input = gr.Files(label='Insert common images')
-                    idv_img_input = gr.Files(label='Insert individual images')
+                    img_formats = ['png',
+                    'jpeg', 'jpg', 'webp', 'svg', 'gif', 'tiff']
+                    cm_img_input = gr.Files(file_types=img_formats, label='Insert common images')
+                    idv_img_input = gr.Files(file_types=img_formats, label='Insert individual images')
 
-                headers = ['ImageId', 'PosX', 'PosY', 'PosPx', 'PosPy']
+                headers = ['ImageId', 'PosX', 'PosY', 'PosPx', 'PosPy', 'SizeX', 'SizeY', 'SizePx', 'SizePy']
 
                 @gr.render(inputs=[count_url, cm_img_input, idv_img_input])
                 def update_df(*items):
                     image_count = sum(len(item) for item in items if item is not None)
                     if image_count is not None:
-                        positions = calculate_positions(image_count)
-                    df = pd.DataFrame(positions, columns=['PosX', 'PosY', 'PosPx', 'PosPy'])
-                    df.insert(0, 'ImageId', range(1, image_count + 1))
+                        positions = calculate_layout(image_count)
+                    df = pd.DataFrame(positions, columns=headers)
+                    # df.insert(0, 'ImageId', range(1, image_count + 1))
                     return df
 
-                pos_df = gr.Dataframe(headers=headers, label="Positions")
-
-                txt_input.change(update_cnt, txt_input, count_url)
-                count_url.change(update_df, count_url, pos_df)
-                cm_img_input.change(update_df, cm_img_input, pos_df)
-                idv_img_input.change(update_df, idv_img_input, pos_df)
-
         with gr.Column():
             file_output = gr.File(label="Download ZIP")
             with gr.Accordion(open=True, label="Gallery"):
@@ -83,19 +82,29 @@ with gr.Blocks() as demo:
                 preview_output = gr.TextArea(label="Raw Text")
 
 
+    with gr.Row():
+        inputs = [
+            txt_input, cm_img_input, idv_img_input
+        ]
+        examples =     [
+            ['https://example.com',
+            ['demo/demo.jpg'],
+            ['demo/logo.png']
+            ]
+        ]
+        gr.Examples(examples, inputs)
+
+    with gr.Row():
+        df = gr.Dataframe(headers=headers, label="Positions")
+
+    txt_input.change(update_cnt, txt_input, count_url)
+    count_url.change(update_df, count_url, df)
+    cm_img_input.change(update_df, cm_img_input, df)
+    idv_img_input.change(update_df, idv_img_input, df)
+
     # example_temp_html = TextProcessor.apply_style('demo/demo.md', 'style.css') # TODO
     with open('demo/demo.md') as f:
         demo_txt = f.read()
-    examples =     [
-        ['https://example.com',
-        ['demo/demo.jpg'],
-        ['demo/demo.jpg']
-        ]
-    ]
-    inputs = [
-        txt_input, cm_img_input, idv_img_input
-    ]
-    gr.Examples(examples, inputs)
 
     submit_button.click(
         UrlProcessor.shorten_and_generate_qr,
@@ -107,7 +116,7 @@ with gr.Blocks() as demo:
             qr_checkbox,
             cm_img_input,
             idv_img_input,
-            pos_df,
+            df,
             ],
         outputs=[preview_output, gallery_output, file_output, json_output]
     )

src/modules/link.py

@@ -102,63 +102,63 @@ class UrlProcessor:
 
         if urls is not None:
             urls = urls if urls is not None else []
-        for idx, url in enumerate(urls):
-            shorten_url, shorten_response_json = None, None
-            try:
-                if shorten:
-                    shorten_url, shorten_response_json = bitly.shorten(url)
-                    all_json_responses.append(shorten_response_json)
-
-                if shorten and shorten_url:
-                    url_to_process = shorten_url
-                else:
-                    url_to_process = url
-
-                if generate_qr and url_to_process:
-                    if shorten_url:
-                        qr_html, qr_png, qr_json = bitly.generate_qr_local(url_to_process)
-                    else:
-                        qr_html, qr_png, qr_json = bitly.generate_qr_local(url_to_process)
-
-                    if qr_png:
-                        os.makedirs(f'{tmpd}/img/qr', exist_ok=True)
-                        qr_png_path = f'img/qr/QR{idx:05d}.png'
-                        qr_path = os.path.join(tmpd, qr_png_path)
-                        with open(qr_path, 'wb') as f:
-                            f.write(qr_png)
-                        markdown_links = markdown_links.replace(
-                            url, f'<img src="{qr_png_path}" height="40"> [{url_to_process}]({url}) '
-                        )
-                        qr_pngs.append(qr_path)
-                        qr_svgs.append(qr_html)
-                        all_json_responses.append(qr_json)
+            for idx, url in enumerate(urls):
+                shorten_url, shorten_response_json = None, None
+                try:
+                    if shorten:
+                        shorten_url, shorten_response_json = bitly.shorten(url)
+                        all_json_responses.append(shorten_response_json)
+
+                    if shorten and shorten_url:
+                        url_to_process = shorten_url
                     else:
-                        results.append(("Error generating QR code", url_to_process))
-                elif generate_qr:
-                    qr_html, qr_png, qr_json = bitly.generate_qr_local(url)
-                    if qr_png:
-                        os.makedirs(f'{tmpd}/img/qr', exist_ok=True)
-                        qr_png_path = f'img/qr/QR{idx:05d}.png'
-                        qr_path = os.path.join(tmpd, qr_png_path)
-                        with open(qr_path, 'wb') as f:
-                            f.write(qr_png)
+                        url_to_process = url
+
+                    if generate_qr and url_to_process:
+                        if shorten_url:
+                            qr_html, qr_png, qr_json = bitly.generate_qr_local(url_to_process)
+                        else:
+                            qr_html, qr_png, qr_json = bitly.generate_qr_local(url_to_process)
+
+                        if qr_png:
+                            os.makedirs(f'{tmpd}/img/qr', exist_ok=True)
+                            qr_png_path = f'img/qr/QR{idx:05d}.png'
+                            qr_path = os.path.join(tmpd, qr_png_path)
+                            with open(qr_path, 'wb') as f:
+                                f.write(qr_png)
+                            markdown_links = markdown_links.replace(
+                                url, f'<img src="{qr_png_path}" height="40"> [{url_to_process}]({url}) '
+                            )
+                            qr_pngs.append(qr_path)
+                            qr_svgs.append(qr_html)
+                            all_json_responses.append(qr_json)
+                        else:
+                            results.append(("Error generating QR code", url_to_process))
+                    elif generate_qr:
+                        qr_html, qr_png, qr_json = bitly.generate_qr_local(url)
+                        if qr_png:
+                            os.makedirs(f'{tmpd}/img/qr', exist_ok=True)
+                            qr_png_path = f'img/qr/QR{idx:05d}.png'
+                            qr_path = os.path.join(tmpd, qr_png_path)
+                            with open(qr_path, 'wb') as f:
+                                f.write(qr_png)
+                            markdown_links = markdown_links.replace(
+                                url, f'<img src="{qr_png_path}" height="40"> [{url}]({url}) '
+                            )
+                            qr_pngs.append(qr_path)
+                            qr_svgs.append(qr_html)
+                            all_json_responses.append(qr_json)
+                        else:
+                            results.append(("Error generating QR code", url))
+                    elif shorten_url:
                         markdown_links = markdown_links.replace(
-                            url, f'<img src="{qr_png_path}" height="40"> [{url}]({url}) '
+                            url, f'[{shorten_url}]({url}) '
                         )
-                        qr_pngs.append(qr_path)
-                        qr_svgs.append(qr_html)
-                        all_json_responses.append(qr_json)
+                        results.append((None, shorten_url))
                     else:
-                        results.append(("Error generating QR code", url))
-                elif shorten_url:
-                    markdown_links = markdown_links.replace(
-                        url, f'[{shorten_url}]({url}) '
-                    )
-                    results.append((None, shorten_url))
-                else:
-                    results.append(("Error shortening URL", url))
-            except Exception as e:
-                results.append((str(e), url))
+                        results.append(("Error shortening URL", url))
+                except Exception as e:
+                    results.append((str(e), url))
 
 
         processor = ImageProcessor()
@@ -166,30 +166,45 @@ class UrlProcessor:
 
         os.makedirs(f'{tmpd}/img/cards', exist_ok=True)
 
-        if qr_pngs is not None or individual_images is not None:
-            qr_pngs = qr_pngs if qr_pngs is not None else []
-            individual_images = individual_images if individual_images is not None else []
+        if qr_pngs and individual_images:
+            num_iterations = len(qr_pngs) * len(individual_images)
+        elif qr_pngs:
+            num_iterations = len(qr_pngs)
+        elif individual_images:
+            num_iterations = len(individual_images)
+        else:
+            num_iterations = 1
+
+        for idx in range(num_iterations):
+            qr_idx = idx % len(qr_pngs) if qr_pngs else 0
+            indv_idx = idx // len(qr_pngs) if individual_images else 0
 
-            for idx, (qr, indv) in enumerate(itertools.product(qr_pngs, individual_images), start=1):
+            qr = qr_pngs[qr_idx] if qr_pngs else None
+            indv = individual_images[indv_idx] if individual_images else None
+
+            if qr or indv:
+                print(idx)
                 try:
-                    i = int(idx) - 1
-                    print(i)
-                    pos_x = int(positions_df.loc[i, 'PosX'])
-                    pos_y = int(positions_df.loc[i, 'PosY'])
+                    pos_x = int(positions_df.loc[idx, 'PosX'])
+                    pos_y = int(positions_df.loc[idx, 'PosY'])
+                    pos_px = int(positions_df.loc[idx, 'PosPx'])
+                    pos_py = int(positions_df.loc[idx, 'PosPy'])
 
-                    size = (int(91 * 3.7795), int(55 * 3.7795))
+                    size_x = int(positions_df.loc[idx, 'SizeX'])
+                    size_y = int(positions_df.loc[idx, 'SizeY'])
+                    size_px = int(positions_df.loc[idx, 'SizePx'])
+                    size_py = int(positions_df.loc[idx, 'SizePy'])
 
+                    size = (int(91 * 3.7795), int(55 * 3.7795))
                     if common_images:
                         for common_img in common_images:
-                            layer = processor.combine_images(layer, common_img, size, (pos_x, pos_y))
-                    if individual_images:
-                        layer = processor.combine_images(layer, indv, size, (pos_x, pos_y))
+                            layer = processor.combine_images(layer, common_img, size, (0, 0))
 
-                    if qr:
-                        qr_size = (int(size[0] * 0.1), int(size[1] * 0.1))
-                        qr_pos = (int(0.9 * pos_x * 3.7795), int(0.9 * pos_y * 3.7795))
-                        layer = processor.combine_images(layer, qr, qr_size, qr_pos)
+                    if indv:
+                        layer = processor.combine_images(layer, indv, (size_x, size_y), (pos_x, pos_y))
 
+                    if qr:
+                        layer = processor.combine_images(layer, qr, (size_px, size_py), (pos_px, pos_py))
 
                     card_png_path = f'img/cards/CD{idx:05d}.png'
                     card_path = os.path.join(tmpd, card_png_path)
@@ -206,7 +221,6 @@ class UrlProcessor:
                 except Exception as e:
                     raise Exception(f"Error combining images: {e}")
 
-
         try:
             json_output_path = os.path.join(tmpd, 'response.json')
             with open(json_output_path, 'w') as json_file: