Update Doors_Schedule.py

Doors_Schedule.py

@@ -92,6 +92,9 @@ 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")
@@ -261,131 +264,10 @@ 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
@@ -573,7 +455,6 @@ 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)
@@ -685,7 +566,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 = []
 
@@ -727,50 +608,6 @@ def get_similar_colors_secondary(selected_columns_new, user_input):
       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):
@@ -873,60 +710,6 @@ 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)
@@ -954,7 +737,7 @@ def get_cleaned_data_secondary(locations, main_info, secondary_info):
 
 
   if len(main_info) == 3 and len(secondary_info) == 1:
-    for coords, label, width, color, acous in locations:
+    for coords, label, widht, color, acous in locations:
         if len(coords)>1:
           index = processed[label] % len(coords)  # Round-robin indexing
           new_coord = [coords[index]]  # Pick the correct coordinate
@@ -1014,7 +797,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):
@@ -1030,28 +813,8 @@ def get_cleaned_data_gpt(locations):
       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)):
@@ -1066,7 +829,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, acous, clr = loc
+            coor, lbl, clr, acous = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1087,7 +850,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, acous, fire, clr = loc
+            coor, lbl, clr, acous, fire = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1108,9 +871,7 @@ 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:
-            if len(loc) != 5:
-                continue
-            coor, lbl, w, acous, clr = loc
+            coor, lbl, w, clr, acous = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1131,7 +892,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, acous, fire, clr = loc
+            coor, lbl, w, clr, acous, fire = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1152,7 +913,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, acous, clr = loc
+            coor, lbl, w, h, clr, acous = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1173,7 +934,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, acous, fire, clr = loc
+            coor, lbl, w, h, clr, acous, fire = loc
             clr = (clr[0] / 255, clr[1] / 255, clr[2] / 255)
             for cor in coor:
                 #Create a Circle annotation (Count Markup)
@@ -1200,7 +961,6 @@ 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:
@@ -1255,7 +1015,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
 
@@ -1327,83 +1087,6 @@ from PyPDF2.generic import TextStringObject  # ✅ Required for setting string v
     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:
@@ -1474,179 +1157,115 @@ 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))
-    print("mainRun is Running")
-    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}")
+  #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)
       
-    dfs = extract_tables(schedule)
-
-    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)
+      pdfs = []
+      for p in plan:
           plan_texts = read_text(p)
-
-          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)
-                                    
+          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:
-              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)  
+              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)
           
 
-        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 
+  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)
+          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)
+          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 = []
+
+  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 
+
+