course schedule

app.py

@@ -1,146 +1,90 @@
+import os
 import gradio as gr
-import numpy as np
-import random
-from diffusers import DiffusionPipeline
-import torch
+import pandas as pd
+from groq import Groq
+from dotenv import load_dotenv
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
+os.environ['REQUESTS_CA_BUNDLE'] = '/usr/local/share/zscaler.crt'
 
-if torch.cuda.is_available():
-    torch.cuda.max_memory_allocated(device=device)
-    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", torch_dtype=torch.float16, variant="fp16", use_safetensors=True)
-    pipe.enable_xformers_memory_efficient_attention()
-    pipe = pipe.to(device)
-else: 
-    pipe = DiffusionPipeline.from_pretrained("stabilityai/sdxl-turbo", use_safetensors=True)
-    pipe = pipe.to(device)
 
-MAX_SEED = np.iinfo(np.int32).max
-MAX_IMAGE_SIZE = 1024
+load_dotenv()
 
-def infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps):
 
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-        
-    generator = torch.Generator().manual_seed(seed)
-    
-    image = pipe(
-        prompt = prompt, 
-        negative_prompt = negative_prompt,
-        guidance_scale = guidance_scale, 
-        num_inference_steps = num_inference_steps, 
-        width = width, 
-        height = height,
-        generator = generator
-    ).images[0] 
+def read_excel_and_process(fi):
+    excel_file = pd.ExcelFile(fi)
+
+    new_data = {}
+    row_names = ['8:30-9:50', '10-11:20', '11:30-12:50', '1-2:20', '2:30-3:50', '4-5:20', '6-7:20', '7:30-8:50']
+    col_names = ['Time', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday/Sunday']
+
+    for t in row_names:
+        new_data[t] = {}
+        for d in col_names:
+            new_data[t][d] = []
+
+    for sheet_name in excel_file.sheet_names:
+        print(f"Processing sheet: {sheet_name}")
+
+        df = excel_file.parse(sheet_name)
+
+        # row_index = df.index
+        # col_names = df.columns
+        for i in range(0, len(row_names)):
+            for j in range(1, len(col_names)):
+                cell_value = df.iat[i, j]
+                if pd.isna(cell_value):
+                    continue
+                if str(cell_value).find('Common') > -1:
+                    continue
+
+                row_name = row_names[i]
+                col_name = col_names[j]
+
+                new_data[row_name][col_name].append("{}, {}".format(str(cell_value).strip(), str(sheet_name).strip()))
+                print(f"Sheet: {sheet_name}, Row: {row_name}, Column: {col_name}, Value: {cell_value}")
+
+    for t, v in new_data.items():
+        for d, vv in v.items():
+            new_data[t][d].sort()
+            new_data[t][d] = "\n".join(new_data[t][d])
+
+    data_2 = []
+    for t, v in new_data.items():
+        v['Time'] = t
+        data_2.append(v)
+
+    df = pd.DataFrame.from_dict(data_2)
+    df.to_excel("visualization.xlsx", index=False)
+    return "visualization.xlsx"
+
+
+# def excel_to_csv(fi):
+#     df = pd.read_excel(fi)
+
+#     clm = []
+#     for c in df.columns:
+#         clm.append(c)
     
-    return image
-
-examples = [
-    "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
-    "An astronaut riding a green horse",
-    "A delicious ceviche cheesecake slice",
-]
-
-css="""
-#col-container {
-    margin: 0 auto;
-    max-width: 520px;
-}
-"""
-
-if torch.cuda.is_available():
-    power_device = "GPU"
-else:
-    power_device = "CPU"
-
-with gr.Blocks(css=css) as demo:
+#     df = df.to_csv(path_or_buf = "here2.csv")
+
+#     return gr.Dropdown(choices=clm, value=clm, label="Columns of the file", multiselect=True, allow_custom_value=True), "here2.csv"
+
+
+with gr.Blocks() as demo:
     
-    with gr.Column(elem_id="col-container"):
-        gr.Markdown(f"""
-        # Text-to-Image Gradio Template
-        Currently running on {power_device}.
-        """)
-        
-        with gr.Row():
-            
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
-            
-            run_button = gr.Button("Run", scale=0)
+    with gr.Tab("Excel to Neo4J"):
+        gr.Markdown("### Visualize your course schedule.")
+
+        ex_fi = gr.File(file_count='single')
+
+        result_fi = gr.File(file_count='single')
         
-        result = gr.Image(label="Result", show_label=False)
-
-        with gr.Accordion("Advanced Settings", open=False):
-            
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
-            
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
-            )
-            
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-            
-            with gr.Row():
-                
-                width = gr.Slider(
-                    label="Width",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=512,
-                )
-                
-                height = gr.Slider(
-                    label="Height",
-                    minimum=256,
-                    maximum=MAX_IMAGE_SIZE,
-                    step=32,
-                    value=512,
-                )
-            
-            with gr.Row():
-                
-                guidance_scale = gr.Slider(
-                    label="Guidance scale",
-                    minimum=0.0,
-                    maximum=10.0,
-                    step=0.1,
-                    value=0.0,
-                )
-                
-                num_inference_steps = gr.Slider(
-                    label="Number of inference steps",
-                    minimum=1,
-                    maximum=12,
-                    step=1,
-                    value=2,
-                )
+        # upload to process
+        ex_fi.upload(read_excel_and_process, inputs=ex_fi, outputs=result_fi)
+
+        # click to process
+        # btn_submit = gr.Button("Submit")
+        # btn_submit.click(text_to_neo4j, inputs=[remarks, columns], outputs=[result_fi,result_ta])/
         
-        gr.Examples(
-            examples = examples,
-            inputs = [prompt]
-        )
-
-    run_button.click(
-        fn = infer,
-        inputs = [prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps],
-        outputs = [result]
-    )
-
-demo.queue().launch()
+    
+demo.launch()