Update Doors_Schedule.py

Doors_Schedule.py

@@ -92,9 +92,6 @@ def flexible_search(df, search_terms):
     return results
 
 
-
-
-
 def generate_current_table_without_cropping(clm_idx, clmn_name, df):
   selected_df = df.iloc[:, clm_idx]
   print("hello I generated the selected columns table without cropping")
@@ -264,10 +261,131 @@ def get_selected_columns(dfs, user_patterns):
 
 
 
+def separate_main_secondary(input_user_clmn_names):
+  main_info = input_user_clmn_names[:4]
+  secondary_info = input_user_clmn_names[4:]
+  return main_info, secondary_info
+
+    
+# take main info
+def get_column_name(user_input_m):
+  #get empty indices
+  empty_indices = [i for i, v in enumerate(user_input_m) if v == '']
+
+  # fixed column names
+  fixed_list = ["door_id", "door_type", "width", "height"]
+  for i in range(len(empty_indices)):
+    if empty_indices[i] == 3:
+      fixed_list[2] = "structural_opening"
+    fixed_list[empty_indices[i]] = ""
+
+  #finalize the column name structure
+  clmn_name_m = [i for i in fixed_list if i]
+
+  return clmn_name_m
+
+# take secondary info
+def get_column_name_secondary(user_input_m):
+  #get empty indices
+  empty_indices = [i for i, v in enumerate(user_input_m) if v == '']
+
+  # fixed column names
+  fixed_list = ["fire_rate", "acoustic_rate"]
+  for i in range(len(empty_indices)):
+    fixed_list[empty_indices[i]] = ""
+
+  #finalize the column name structure
+  clmn_name_m = [i for i in fixed_list if i]
+
+  return clmn_name_m
+
+
+#handling both main and secondary info together in one table
+def get_selected_columns_all(dfs, user_patterns):
+  selected_columns = []
+  selected_columns_new = None # Initialize selected_columns_new to None
+
+  for i in range(len(dfs)):
+
+
+
+
+
+    main_info, secondary_info = separate_main_secondary(user_patterns)
+    clmn_name_main = get_column_name(main_info)
+    non_empty_main_info = [item for item in main_info if item]
+
+    clmn_name_secondary = get_column_name_secondary(secondary_info)
+
+
+    non_empty_secondary_info = [item for item in secondary_info if item]
+
+    clmn_name = clmn_name_main + clmn_name_secondary
+    non_empty_info = non_empty_main_info + non_empty_secondary_info
+
+    #print(f"main info: {main_info}")
+    print(f"clmn name: {clmn_name}")
+    print(f"non-empty info: {non_empty_info}")
+    #print(f"length of non-empty info: {len(non_empty_main_info)}")
+
+
+    cell_columns_appearance = flexible_search(dfs[i], non_empty_info)
+    cell_matches, col_matches = analyse_cell_columns(cell_columns_appearance)
+
+    print(f"length of cell_matches: {len(cell_matches)}")
+    print(f"cell_matches: {cell_matches}")
+    #clmn_name = map_user_input_to_standard_labels(user_patterns)
+    #if len(clmn_name) < len(user_patterns):
+
+
+
+
+    print(clmn_name)
+
+    if len(cell_matches) == 0 and len(col_matches) == 0:
+      print(f"this is df {i}, SEARCH IN ANOTHER DF")
+
+    else:
+      #IN COLUMNS
+      if len(col_matches) == len(non_empty_info):
+        column_index_list = get_column_index(col_matches)
+        print(f"this is df {i} mawgooda fel columns, check el df length 3ashan law el details fe table tany")
+        #print(len(clm_idx))
+        #details in another table
+        print(column_index_list)
+        if len(dfs[i]) <10:
+          selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
+          #break
+          #other_matches = details_in_another_table_mod(clmn_name, clmn_idx, dfs[i], dfs)
+        #details in the same table
+        if len(dfs[i]) >10:
+          selected_columns_new = generate_current_table_without_cropping(column_index_list,dfs[i])
+          #break
+
+      #IN CELLS
+      if len(cell_matches) == len(non_empty_info):
+        row_index_list, column_index_list = get_row_column_indices(cell_matches)
+        print(f"this is df {i} mawgooda fel cells, check el df length 3ashan law el details fe table tany")
+
+        #details in another table
+        #if len(dfs[i]) <2:
+          #selected_columns_new = details_in_another_table(clmn_name, clmn_idx, dfs[i], dfs)
+        selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
+        selected_columns_new = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+
+        break
+            #other_matches = details_in_another_table_mod(clmn_name, clmn_idx, dfs[i], dfs)
+        ##details in the same table
+        #if len(dfs[i]) >2:
+         # #print(f"this is df {i} call crop_rename_table(indices, clmn_name, clmn_idx,df)")
+          #break
+  return selected_columns_new
+
+
 # 3ayz akhaleehaa te search fel selected_columns column names nafsaha
 # 7ab2a 3ayz a3raf bardo maktooba ezay fel df el 7a2e2ya (akeed za ma el user medakhalha bezabt)
 def get_st_op_pattern(selected_columns, user_input):
-    target = 'structural opening'
+    target = 'structural_opening'
     if target in selected_columns.columns:
       name = user_input[2]
       return name
@@ -455,6 +573,7 @@ def get_cleaned_width(width_info_tobeprinted):
     cleaned_width.append(clean_dimensions(w))  
   return cleaned_width
 
+
 def get_widths_bb_format(cleaned_width, kelma):
   pattern = r"\bW(?:idth)?\s*[×x]\s*H(?:eight)?\b"
   match = re.search(pattern, kelma)
@@ -566,7 +685,7 @@ def get_similar_colors_secondary(selected_columns_new, user_input):
 
     return dict(col_dict)
 
-def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
+'''def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
   width_info_tobeprinted = []
   secondary_info_tobeprinted = []
 
@@ -608,6 +727,50 @@ def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
       h = int(float(h))
       width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
       secondary_info_tobeprinted.append((acous, fire))
+  return width_info_tobeprinted, secondary_info_tobeprinted'''
+
+def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
+  width_info_tobeprinted = []
+  secondary_info_tobeprinted = []
+
+  if len(main_info) == 2 and len(secondary_info) == 1:
+   for coords, label, acous, color in new_data:
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 2 and len(secondary_info) == 2:
+    for coords, label, acous, fire, color in new_data:
+       secondary_info_tobeprinted.append((acous, fire))
+
+  if len(main_info) == 3 and len(secondary_info) == 1:
+    for coords, label, width, acous, color in new_data:
+      width_info_tobeprinted.append(width)
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 3 and len(secondary_info) == 2:
+    for coords, label, width, acous, fire, color in new_data:
+      width_info_tobeprinted.append(width)
+      secondary_info_tobeprinted.append((acous, fire))
+
+  if len(main_info) == 4 and len(secondary_info) == 1:
+    for coords, label, width, height, acous, color in new_data:
+      w = re.sub(r",", "", width)
+      h = re.sub(r",", "", height)
+      w = int(float(w))
+      h = int(float(h))
+      width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 4 and len(secondary_info) == 2:
+    for coords, label, width, height, acous, fire, color in new_data:
+      w = re.sub(r",", "", width)
+      h = re.sub(r",", "", height)
+      w = int(float(w))
+      h = int(float(h))
+      width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
+      secondary_info_tobeprinted.append((acous, fire))
   return width_info_tobeprinted, secondary_info_tobeprinted
 
 def get_flattened_tuples_list_SECONDARY(col_dict):
@@ -710,6 +873,60 @@ def get_word_locations_plan_secondary(flattened_list, plan_texts, main_info, sec
       locations.append((location, lbl, w, h, clr,acoustic))
   return locations, not_found
 
+### newest, accept combined table
+from collections import defaultdict
+import random
+
+def get_similar_colors_all(selected_columns_new):
+    def generate_rgb():
+        return (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+
+    unique_keys = selected_columns_new['door_type'].unique()
+    key_colors = {key: generate_rgb() for key in unique_keys}
+
+    #Column fields
+    clmns_fields = selected_columns_new.columns.to_list()
+
+    def col_template():
+        d = {
+            'values': [],
+            'color': None
+        }
+        for field in clmns_fields:
+            d[field] = []
+        return d
+
+    col_dict = defaultdict(col_template)
+
+    for _, row in selected_columns_new.iterrows():
+        key = row['door_type']
+        col_dict[key]['values'].append(row['door_id'])
+
+        for field in clmns_fields:
+            col_dict[key][field].append(row.get(field, None))
+
+        col_dict[key]['color'] = key_colors[key]
+
+    return dict(col_dict)
+
+### newest, accept combined table
+def get_flattened_tuples_list_all(col_dict):
+    exclude_fields = ['door_type', 'values']
+    flattened_list = []
+
+    for values_dict in col_dict.values():
+        # All fields that are lists and not in the excluded fields
+        list_fields = [k for k, v in values_dict.items()
+                       if isinstance(v, list) and k not in exclude_fields]
+        n_rows = len(values_dict[list_fields[0]]) if list_fields else 0
+
+        for i in range(n_rows):
+            tuple_row = tuple(values_dict[field][i] for field in list_fields) + (values_dict['color'],)
+            flattened_list.append(tuple_row)
+
+    return flattened_list
+
+
 #SECONDARY
 def get_cleaned_data_secondary(locations, main_info, secondary_info):
   processed = defaultdict(int)
@@ -737,7 +954,7 @@ def get_cleaned_data_secondary(locations, main_info, secondary_info):
 
 
   if len(main_info) == 3 and len(secondary_info) == 1:
-    for coords, label, widht, color, acous in locations:
+    for coords, label, width, color, acous in locations:
         if len(coords)>1:
           index = processed[label] % len(coords)  # Round-robin indexing
           new_coord = [coords[index]]  # Pick the correct coordinate
@@ -797,7 +1014,7 @@ def get_cleaned_data_gpt(locations):
 
     return new_data
 
-def get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info):
+'''def get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info):
   secondary_printed_clean = []
   if len(secondary_info) == 1:
     if any('Acoustic' in col for col in selected_secondary_info.columns):
@@ -813,8 +1030,28 @@ def get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprint
       new_text = f"fire rating: {fire}; acoustic rating: {acous}"
       secondary_printed_clean.append(new_text)
       print(new_text)
+  return secondary_printed_clean'''
+
+
+def get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info):
+  secondary_printed_clean = []
+  if len(secondary_info) == 1:
+    if any('acoustic' in col for col in selected_secondary_info.columns):
+      for acous in secondary_tobeprinted:
+        new_text = f"acoustic rating: {acous};"
+        secondary_printed_clean.append(new_text)
+    if any('fire' in col for col in selected_secondary_info.columns):
+      for fire in secondary_tobeprinted:
+        new_text = f"fire rating: {fire};"
+        secondary_printed_clean.append(new_text)
+  if len(secondary_info) == 2:
+    for fire, acous in secondary_tobeprinted:
+      new_text = f"fire rating: {fire}; acoustic rating: {acous};"
+      secondary_printed_clean.append(new_text)
+      print(new_text)
   return secondary_printed_clean
 
+
 def mix_width_secondary(widths, secondary_printed_clean):
   all_print = []
   for i in range(len(widths)):
@@ -829,7 +1066,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
     page = pdf_document[0]  # First page
     if len(main_info) == 2 and len(secondary_info) == 1:
         for loc in locations:
-            coor, lbl, clr, acous = loc
+            coor, lbl, acous, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -850,7 +1087,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     if len(main_info) == 2 and len(secondary_info) == 2:
         for loc in locations:
-            coor, lbl, clr, acous, fire = loc
+            coor, lbl, acous, fire, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -871,7 +1108,9 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     if len(main_info) == 3 and len(secondary_info) == 1:
         for loc in locations:
-            coor, lbl, w, clr, acous = loc
+            if len(loc) != 5:
+                continue
+            coor, lbl, w, acous, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -892,7 +1131,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     if len(main_info) == 3 and len(secondary_info) == 2:
         for loc in locations:
-            coor, lbl, w, clr, acous, fire = loc
+            coor, lbl, w, acous, fire, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -913,7 +1152,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     if len(main_info) == 4 and len(secondary_info) == 1:
         for loc in locations:
-            coor, lbl, w, h, clr, acous = loc
+            coor, lbl, w, h, acous, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -934,7 +1173,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     if len(main_info) == 4 and len(secondary_info) == 2:
         for loc in locations:
-            coor, lbl, w, h, clr, acous, fire = loc
+            coor, lbl, w, h, acous, fire, clr = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -961,6 +1200,7 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
     pdf_document.close()
 
     return output_stream.getvalue()  # Return the modified PDF as bytes
+
 def get_user_input(user_words):
     user_input = []
     for item in user_words:
@@ -1015,7 +1255,7 @@ import PyPDF2
 import io
 from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
 
-def add_bluebeam_count_annotations(pdf_bytes, locations):
+'''def add_bluebeam_count_annotations(pdf_bytes, locations):
     pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
     pdf_document = fitz.open("pdf", pdf_stream.read())  # Open PDF in memory
 
@@ -1087,6 +1327,83 @@ def add_bluebeam_count_annotations(pdf_bytes, locations):
     pdf_document.close()
 
     return output_stream.getvalue()  # Return the modified PDF as bytes
+'''
+def add_bluebeam_count_annotations(pdf_bytes, locations):
+    pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
+    pdf_document = fitz.open("pdf", pdf_stream.read())  # Open PDF in memory
+
+    page = pdf_document[0]  # First page
+    print(f"length of locations 0 from not sec presence: {len(locations[0])}")
+
+    for loc in locations:
+
+      if len(loc) == 3:
+            coor, lbl, clr = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+      if len(loc) == 4:
+            coor, lbl, clr,w = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+      if len(loc) == 5:
+            coor, lbl, clr,w,h = loc
+            clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
+            for cor in coor:
+                #Create a Circle annotation (Count Markup)
+                annot = page.add_circle_annot(
+                    fitz.Rect(cor[0] - 10, cor[1] - 10, cor[0] + 10, cor[1] + 10)  # Small circle
+                )
+
+                #Assign required Bluebeam metadata
+                annot.set_colors(stroke=clr, fill=(1, 1, 1))  # Set stroke color and fill white
+                annot.set_border(width=2)  # Border thickness
+                annot.set_opacity(1)  # Fully visible
+
+                #Set annotation properties for Bluebeam Count detection
+                annot.set_info("name", lbl)  # Unique name for each count
+                annot.set_info("subject", "Count")  #Bluebeam uses "Count" for Count markups
+                annot.set_info("title", lbl)  # Optional
+                annot.update()  # Apply changes
+
+    #Save modified PDF to a variable instead of a file
+    output_stream = io.BytesIO()
+    pdf_document.save(output_stream)
+    pdf_document.close()
+
+    return output_stream.getvalue()  # Return the modified PDF as bytes
+
+
 def get_user_input(user_words):
     user_input = []
     for item in user_words:
@@ -1157,115 +1474,178 @@ def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     # #Save the final modified PDF to disk
     # with open(output_pdf_path, "wb") as file:
     #     file.write(final_pdf_bytes)
-        
+
+def process_pdf_secondary(input_pdf_path, output_pdf_path, locations, new_authors, main_info, secondary_info):
+    
+    if isinstance(input_pdf_path, bytes):
+      original_pdf_bytes = input_pdf_path
+    else:
+        with open(input_pdf_path, "rb") as file:
+            original_pdf_bytes = file.read()
+
+    #Add Bluebeam-compatible count annotations
+    annotated_pdf_bytes = add_bluebeam_count_annotations_secondary(original_pdf_bytes, locations, main_info, secondary_info)
+
+    #Modify author field using PyPDF2
+    final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
+
+    return final_pdf_bytes
+
+
+def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
+    #Load original PDF
+    if isinstance(input_pdf_path, bytes):
+        original_pdf_bytes = input_pdf_path
+    else:
+        with open(input_pdf_path, "rb") as file:
+            original_pdf_bytes = file.read()
+
+    #Add Bluebeam-compatible count annotations
+    annotated_pdf_bytes = add_bluebeam_count_annotations(original_pdf_bytes, locations)
+
+    #Modify author field using PyPDF2
+    final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
+    return final_pdf_bytes
 def mainRun(schedule, plan, searcharray):
-  #print(type(plan))
-  eltype = type(plan)
-  print(f"el type beta3 variable plan:: {eltype}")
-  len_plan = len(plan)
-  print(f"length of the plan's array is: {len_plan}")
-  p1_type = type(plan[0])
-  print(f"el mawgood fe p[0]: {p1_type}")
-  
-  user_input = get_user_input(searcharray)
-  secondary_info_presence = False
-  if len(user_input) > 4:
-      secondary_info_presence = True
-      secondary_info = user_input[4:]
-      if not user_input[3]:
-          main_info = user_input[:3]
-      elif len(user_input) > 4:
-          main_info = user_input[:4]
-  
-  
-  dfs = extract_tables(schedule)
-
-  if secondary_info_presence:
-      selected_columns_new = get_selected_columns(dfs, main_info)
-      selected_secondary_info = get_secondary_info(dfs, secondary_info)
-      selected_secondary_info = selected_secondary_info.applymap(lambda x: 'N/A' if isinstance(x, str) and x.strip() == '' else x)
-      selected_columns_combined = pd.concat([selected_columns_new, selected_secondary_info], axis=1)
-      kelma = get_st_op_pattern(selected_columns_new, user_input)
-      col_dict = get_similar_colors_secondary(selected_columns_combined, user_input)
-      flattened_list2 = get_flattened_tuples_list_SECONDARY(col_dict)
+    
+    #print(type(plan))
+    eltype = type(plan)
+    print(f"el type beta3 variable plan:: {eltype}")
+    len_plan = len(plan)
+    print(f"length of the plan's array is: {len_plan}")
+    p1_type = type(plan[0])
+    print(f"el mawgood fe p[0]: {p1_type}")
+    
+    print(f"search array: {searcharray}")
       
-      pdfs = []
-      for p in plan:
-          plan_texts = read_text(p)
-          locations, not_found = get_word_locations_plan_secondary(flattened_list2,plan_texts, main_info, secondary_info)
-          new_data3 = get_cleaned_data_secondary(locations,main_info,secondary_info)
-          repeated_labels = get_repeated_labels(locations)
-          if kelma == None:
-              #widths = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
-              widths, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
-          else:
-              width_info_tobeprinted, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
-              cleaned_width = get_cleaned_width(width_info_tobeprinted)
-              widths = get_widths_bb_format(cleaned_width, kelma)
-          secondary_printed_clean =  get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info)
-          all_print =  mix_width_secondary(widths, secondary_printed_clean)
-          final_pdf_bytes = process_pdf_secondary(p, "final_output_multiple_input_new2.pdf", new_data3, all_print, main_info, secondary_info)
-          pdfs.append(final_pdf_bytes)
-          
+    dfs = extract_tables(schedule)
 
-  else:
-      selected_columns_new = get_selected_columns(dfs, user_input)
-      kelma = get_st_op_pattern(selected_columns_new, user_input)
-      col_dict = get_similar_colors(selected_columns_new)
-      flattened_list = get_flattened_tuples_list(col_dict)
-
-      pdfs = []
-      for p in plan:
-          print(f" p in plan is {type(p)}")
-          print(p)
+    pdfs = []
+    for p in plan:
+        all_new_data = []
+        all_widths = []
+        pdf_outputs = [] 
+        
+        for j in range(len(searcharray)):
+          user_input = searcharray[j]
+            
+          secondary_presence = False
+          if user_input[4] or user_input[5]:
+            secondary_presence = True
+            main_info_, secondary_info_ = separate_main_secondary(user_input)
+            main_info = [item for item in main_info_ if item]
+            secondary_info = [item for item in secondary_info_ if item]        
+            print("feh secondary information")
+            if user_input[4]:
+              print("Fire rate mawgooda")
+            if user_input[5]:
+              print("Acoustic Rate mawgooda")
+          else:
+            print("mafeesh secondary information")
+        
+          selected_columns_combined = get_selected_columns_all(dfs, user_input)
+          kelma = get_st_op_pattern(selected_columns_combined, user_input)
+          col_dict = get_similar_colors_all(selected_columns_combined)
+          flattened_list = get_flattened_tuples_list_all(col_dict)
           plan_texts = read_text(p)
-          locations, not_found = get_word_locations_plan(flattened_list,plan_texts)
-          new_data = get_cleaned_data(locations)
-          repeated_labels = get_repeated_labels(locations)
-          if kelma == None:
-            widths = get_width_info_tobeprinted(new_data)
+
+          if secondary_presence:
+                  plan_texts = read_text(p)
+                  locations, not_found = get_word_locations_plan_secondary(flattened_list,plan_texts, main_info, secondary_info)
+                  new_data3 = get_cleaned_data_secondary(locations,main_info,secondary_info)
+                  
+                  #Single page annotation
+                  all_new_data.append(new_data3)
+                  repeated_labels = get_repeated_labels(locations)
+                  if kelma == None:
+                      widths, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
+                  else:
+                      width_info_tobeprinted, secondary_tobeprinted = get_width_info_tobeprinted_secondary(new_data3, main_info, secondary_info)
+                      cleaned_width = get_cleaned_width(width_info_tobeprinted)
+                      widths = get_widths_bb_format(cleaned_width, kelma)
+                  #Handling schedules without dimensions (width and height)
+                  if selected_columns_combined.shape[1] == 2:
+                    widths = []
+                  
+                  secondary_printed_clean =  get_secondary_tobeprinted_clean(selected_columns_combined, secondary_tobeprinted, secondary_info)
+                  all_print =  mix_width_secondary(widths, secondary_printed_clean)
+
+                  #Single page annotation
+                  all_widths.append(all_print)
+        
+                  #flat_list_new_data = [item for sublist in all_new_data for item in sublist]
+                  #flat_list_widths = [item for sublist in all_widths for item in sublist]
+        
+                  if pdf_outputs:
+                    final_pdf_bytes = process_pdf_secondary(pdf_outputs[j-1], "final_output_multiple_input_new2.pdf", all_new_data[j], all_widths[j], main_info, secondary_info)
+                    pdf_outputs.append(final_pdf_bytes)
+                  else:
+                    final_pdf_bytes = process_pdf_secondary(p, "final_output_multiple_input_new2.pdf", all_new_data[j], all_widths[j], main_info, secondary_info)
+                    pdf_outputs.append(final_pdf_bytes)
+                                    
           else:
-            width_info_tobeprinted = get_width_info_tobeprinted(new_data)
-            cleaned_width = get_cleaned_width(width_info_tobeprinted)
-            widths = get_widths_bb_format(cleaned_width, kelma)
-          final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths)
-          pdfs.append(final_pdf_bytes)
-      
-  if selected_columns_new.shape[1] == 2:
-      widths = []
+              locations, not_found = get_word_locations_plan(flattened_list,plan_texts)
+              new_data = get_cleaned_data(locations)
+              #Single page annotation
+              all_new_data.append(new_data)
+              repeated_labels = get_repeated_labels(locations)
+              if kelma == None:
+                  widths = get_width_info_tobeprinted(new_data)
+              else:
+                  width_info_tobeprinted = get_width_info_tobeprinted(new_data)
+                  cleaned_width = get_cleaned_width(width_info_tobeprinted)
+                  widths = get_widths_bb_format(cleaned_width, kelma)
+
+              #Handling schedules without dimensions (width and height)  
+              if selected_columns_combined.shape[1] == 2:
+                  widths = []
+              
+              #Single page annotation
+              all_widths.append(widths)
+        
+              flat_list_new_data = [item for sublist in all_new_data for item in sublist]
+              flat_list_widths = [item for sublist in all_widths for item in sublist]
+        
+              if pdf_outputs:
+                  final_pdf_bytes = process_pdf(pdf_outputs[j-1], "final_output_width_trial.pdf", all_new_data[j], all_widths[j])
+                  pdf_outputs.append(final_pdf_bytes)
+              else:
+                  final_pdf_bytes = process_pdf(p, "final_output_width_trial.pdf", all_new_data[j], all_widths[j])
+                  pdf_outputs.append(final_pdf_bytes)  
+          
 
-  merged_pdf = merge_pdf_bytes_list(pdfs)
-  print(f"number of pges of merged_pdf is {len(merged_pdf)} and its type is {type(merged_pdf)}")
-  not_found = []
-  doc2 =fitz.open('pdf',merged_pdf)
-  len_doc2 = len(doc2)
-  print(f"number of pges of doc2 is {len_doc2} and its type is {type(doc2)}")
-  page=doc2[0]
-  pix = page.get_pixmap()  # render page to an image
-  pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
-  img=np.array(pl)
-  annotatedimg = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-
-
-  list1=pd.DataFrame(columns=['content',  'id',  'subject','color'])
-
-  # for page in doc:
-  for page in doc2:  
-    # Iterate through annotations on the page
-    for annot in page.annots():
-        # Get the color of the annotation
-        annot_color = annot.colors
-        if annot_color is not None:
-            # annot_color is a dictionary with 'stroke' and 'fill' keys
-            stroke_color = annot_color.get('stroke')  # Border color
-            fill_color = annot_color.get('fill')      # Fill color
-            if fill_color:
-              v='fill'
-              # print('fill')
-            if stroke_color:
-              v='stroke'
-            x,y,z=int(annot_color.get(v)[0]*255),int(annot_color.get(v)[1]*255),int(annot_color.get(v)[2]*255)
-            list1.loc[len(list1)] =[annot.info['content'],annot.info['id'],annot.info['subject'],[x,y,z]]
-  return annotatedimg, doc2 , list1, repeated_labels , not_found 
-
-  
+        pdfs.append(final_pdf_bytes)
+        merged_pdf = merge_pdf_bytes_list(pdfs)
+        print(f"number of pges of merged_pdf is {len(merged_pdf)} and its type is {type(merged_pdf)}")
+    
+    not_found = []
+    doc2 =fitz.open('pdf',merged_pdf)
+    len_doc2 = len(doc2)
+    print(f"number of pges of doc2 is {len_doc2} and its type is {type(doc2)}")
+    page=doc2[0]
+    pix = page.get_pixmap()  # render page to an image
+    pl=Image.frombytes('RGB', [pix.width,pix.height],pix.samples)
+    img=np.array(pl)
+    annotatedimg = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    
+    
+    list1=pd.DataFrame(columns=['content',  'id',  'subject','color'])
+    
+    # for page in doc:
+    for page in doc2:  
+        # Iterate through annotations on the page
+        for annot in page.annots():
+            # Get the color of the annotation
+            annot_color = annot.colors
+            if annot_color is not None:
+                # annot_color is a dictionary with 'stroke' and 'fill' keys
+                stroke_color = annot_color.get('stroke')  # Border color
+                fill_color = annot_color.get('fill')      # Fill color
+                if fill_color:
+                  v='fill'
+                  # print('fill')
+                if stroke_color:
+                  v='stroke'
+                x,y,z=int(annot_color.get(v)[0]*255),int(annot_color.get(v)[1]*255),int(annot_color.get(v)[2]*255)
+                list1.loc[len(list1)] =[annot.info['content'],annot.info['id'],annot.info['subject'],[x,y,z]]
+    return annotatedimg, doc2 , list1, repeated_labels , not_found