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,6 +261,127 @@ 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):
@@ -420,29 +538,22 @@ def get_cleaned_data(locations):
   return new_data
 
 
-# law 0.5 maslan tetkatab we law mesh keda yesheel el decimal point
 def get_width_info_tobeprinted(new_data):
   width_info_tobeprinted = []
   if len(new_data[0]) == 4:
     for _,_,_, w in new_data:
-      #w = re.sub(r",", "", w)
-      #w = int(float(w))
+      w = re.sub(r",", "", w)
+      w = int(float(w))
       width_info_tobeprinted.append(w)
   if len(new_data[0]) == 5:
     for _,_,_, w,h in new_data:
       w = re.sub(r",", "", w)
       h = re.sub(r",", "", h)
-      if float(w).is_integer():
-        w = int(float(w))
-      else:
-        w = w
-      if float(h).is_integer():
-        h = int(float(h))
-      else:
-        h = h
+      w = int(float(w))
+      h = int(float(h))
       width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
   return width_info_tobeprinted
-    
+
 def clean_dimensions(text):
     # Remove commas and "mm"
     text = re.sub(r'[,\s]*mm', '', text)  # Remove "mm" with optional spaces or commas before it
@@ -466,9 +577,9 @@ def get_widths_bb_format(cleaned_width, kelma):
     width_name = int(float(width_name))
     height_name = int(float(height_name))
     if match:
-      full_text = f"{width_name} mm wide x {height_name} mm high"
+      full_text = f"{width_name}mm wide x {height_name}mm high"
     else:
-      full_text = f"{height_name} mm wide x {width_name} mm high"
+      full_text = f"{height_name}mm wide x {width_name}mm high"
     widths.append(full_text)
   return widths
 
@@ -710,6 +821,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)
@@ -797,7 +962,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,6 +978,24 @@ 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):
@@ -913,7 +1096,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)
@@ -961,6 +1144,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:
@@ -1087,6 +1271,8 @@ def add_bluebeam_count_annotations(pdf_bytes, locations):
     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 +1343,276 @@ 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)
+    dfs = extract_tables(schedule)
+
+    all_new_data = []
+    all_widths = []
+    pdf_outputs = []
+    
+    if len(searcharray)>1:
+        for j in range(len(searcharray)):
+          pdfs = []
+          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:
-              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)
+            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)
+        
+          if secondary_presence:
+              for p in plan:
+                  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)
+                  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", flat_list_new_data, flat_list_widths, main_info, secondary_info)
+                    pdf_outputs.append(final_pdf_bytes)
+                  else:
+                    final_pdf_bytes = process_pdf_secondary(p, "final_output_multiple_input_new2.pdf", flat_list_new_data, flat_list_widths, main_info, secondary_info)
+                    pdf_outputs.append(final_pdf_bytes)
+                    
+                  pdfs.append(final_pdf_bytes)
+        
+        
+          else:
+              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)
+                  #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)
+                  #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", flat_list_new_data, flat_list_widths)
+                    #final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths)         
+                    pdfs.append(final_pdf_bytes)
+                  else:
+                    final_pdf_bytes = process_pdf(p, "final_output_width_trial.pdf", flat_list_new_data, flat_list_widths)
+                    #final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths)         
+                    pdfs.append(final_pdf_bytes)  
           
-
-  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)
+          #Handling schedules without dimensions (width and height)  
+          if selected_columns_combined.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)}")
+    
+    else:
+        for j in range(len(searcharray)):
+          pdfs = []
+          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:
-            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 = []
+            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)
+        
+          if secondary_presence:
+              for p in plan:
+                  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)
+                  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]
+        
+                  
+                  final_pdf_bytes = process_pdf_secondary(p, "final_output_multiple_input_new2.pdf", flat_list_new_data, flat_list_widths, main_info, secondary_info)
+                  pdfs.append(final_pdf_bytes)
+        
+        
+          else:
+              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)
+                  #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)
+                  #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]
 
-  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 
+                  final_pdf_bytes = process_pdf(p, "final_output_width_trial.pdf", flat_list_new_data, flat_list_widths)
+                  #final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths)         
+                  pdfs.append(final_pdf_bytes)  
+          
+          #Handling schedules without dimensions (width and height)  
+          if selected_columns_combined.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