Update Doors_Schedule.py

Doors_Schedule.py

@@ -34,11 +34,8 @@ def calculate_midpoint(x1,y1,x2,y2):
   ym = int((y1 + y2) / 2)
   return (xm, ym)
 
-def read_text(input_pdf_path,pdf_content=0):
-    if pdf_content:
-       pdf_document = fitz.open(stream=pdf_content, filetype="pdf")
-    else:
-       pdf_document = fitz.open('pdf',input_pdf_path)
+def read_text(input_pdf_path):
+    pdf_document = fitz.open('pdf',input_pdf_path)
 
     for page_num in range(pdf_document.page_count):
         page = pdf_document[page_num]
@@ -205,11 +202,8 @@ def get_column_index(col_matches):
   return idx
 
 
-def extract_tables(schedule,schedule_content=0):
-  if schedule_content:
-     doc = fitz.open(stream=schedule_content, filetype="pdf")
-  else:
-    doc = fitz.open("pdf",schedule)
+def extract_tables(schedule):
+  doc = fitz.open("pdf",schedule)
   for page in doc:
     tabs = page.find_tables()
   dfs = []
@@ -471,17 +465,552 @@ def get_widths_bb_format(cleaned_width, kelma):
     widths.append(full_text)
   return widths
 
+
+def get_secondary_info(dfs, user_patterns):
+  selected_columns = []
+  selected_columns_new = None # Initialize selected_columns_new to None
+
+  for i in range(len(dfs)):
+    cell_columns_appearance = flexible_search(dfs[i], user_patterns)
+    cell_matches, col_matches = analyse_cell_columns(cell_columns_appearance)
+
+
+    clmn_name = user_patterns
+
+
+    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(user_patterns):
+        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(user_patterns):
+        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]) <10:
+          #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)
+          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:
+          print(f"this is df {i} call crop_rename_table(indices, clmn_name, clmn_idx,df)")
+          selected_columns_new = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+          break
+  return selected_columns_new
+
+def get_similar_colors_secondary(selected_columns_new, user_input):
+    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}
+
+    # Only exclude actual None values; allow empty string column names if they exist in the DataFrame
+    extra_fields = [col for col in user_input[4:] if col is not None]
+
+    def col_template():
+        d = {
+            'values': [],
+            'color': None
+        }
+        if 'structural_opening' in selected_columns_new.columns:
+            d['widths'] = []
+        elif selected_columns_new.shape[1] > 2:
+            d['widths'] = []
+            d['heights'] = []
+        for field in extra_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'])
+
+        if 'structural_opening' in selected_columns_new.columns:
+            col_dict[key]['widths'].append(row['structural_opening'])
+        elif selected_columns_new.shape[1] > 2:
+            col_dict[key]['widths'].append(row.get('width', 0))
+            col_dict[key]['heights'].append(row.get('height', 0))
+
+        for field in extra_fields:
+            col_dict[key][field].append(row.get(field, None))
+
+        col_dict[key]['color'] = key_colors[key]
+
+    return dict(col_dict)
+
+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, color, acous in new_data:
+      secondary_info_tobeprinted.append(acous)
+
+
+  if len(main_info) == 2 and len(secondary_info) == 2:
+    for coords, label, color, acous, fire in new_data:
+       secondary_info_tobeprinted.append((acous, fire))
+
+  if len(main_info) == 3 and len(secondary_info) == 1:
+    for coords, label, width, color, acous 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, color, acous, fire 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, color, acous 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, color, acous, fire 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):
+    tuples_list = []
+
+    for key, values_dict in col_dict.items():
+        # Find actual keys containing "Acoustic" and "Fire"
+        acoustic_key = next((k for k in values_dict if 'acoustic' in k.lower()), None)
+        fire_key = next((k for k in values_dict if 'fire' in k.lower()), None)
+
+        acoustic_values = values_dict.get(acoustic_key, [None] * len(values_dict['values'])) if acoustic_key else [None] * len(values_dict['values'])
+        fire_values = values_dict.get(fire_key, [None] * len(values_dict['values'])) if fire_key else [None] * len(values_dict['values'])
+
+        if 'heights' in values_dict and 'widths' in values_dict:
+            tuples_list.append([
+                (value, width, height, values_dict["color"], acoustic, fire)
+                for value, width, height, acoustic, fire in zip(
+                    values_dict['values'],
+                    values_dict['widths'],
+                    values_dict['heights'],
+                    acoustic_values,
+                    fire_values
+                )
+            ])
+        elif 'widths' in values_dict:
+            tuples_list.append([
+                (value, width, values_dict["color"], acoustic, fire)
+                for value, width, acoustic, fire in zip(
+                    values_dict['values'],
+                    values_dict['widths'],
+                    acoustic_values,
+                    fire_values
+                )
+            ])
+        else:
+            tuples_list.append([
+                (value, values_dict["color"], acoustic, fire)
+                for value, acoustic, fire in zip(
+                    values_dict['values'],
+                    acoustic_values,
+                    fire_values
+                )
+            ])
+
+    flattened_list = [item for sublist in tuples_list for item in sublist]
+
+    return flattened_list
+
+def get_word_locations_plan_secondary(flattened_list, plan_texts, main_info, secondary_info):
+  #hena fe 7alet en keda keda fe secondary information
+  locations = []
+  not_found = []
+  len_main = len(main_info) #3 or #4 #sometimes maybe 2
+  len_secondary = len(secondary_info) #2 or #1
+
+  if len_main == 2 and len_secondary == 2:
+    for lbl, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, acoustic, fire))
+
+  if len_main == 2 and len_secondary == 1:
+    for lbl, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, clr, acoustic))
+
+
+
+  if len_main == 3 and len_secondary == 2:
+    for lbl, w, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, clr, acoustic, fire))
+
+  if len_main == 3 and len_secondary == 1:
+    for lbl, w, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, clr, acoustic))
+
+
+
+  if len_main == 4 and len_secondary == 2:
+    for lbl, w, h, clr, acoustic, fire in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, h, clr, acoustic, fire))
+
+  if len_main == 4 and len_secondary == 1:
+    for lbl, w, h, clr, acoustic in flattened_list:
+      location,worz, txt_pt = find_text_in_plan(lbl, plan_texts)
+      if len(location) ==0:
+        not_found.append(lbl)
+      locations.append((location, lbl, w, h, clr,acoustic))
+  return locations, not_found
+
+#SECONDARY
+def get_cleaned_data_secondary(locations, main_info, secondary_info):
+  processed = defaultdict(int)
+
+  new_data = []
+  if len(main_info) == 2 and len(secondary_info) == 1:
+    for coords, label, color, acous in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, acous))
+
+  if len(main_info) == 2 and len(secondary_info) == 2:
+    for coords, label, color, acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, color, acous, fire))
+
+
+  if len(main_info) == 3 and len(secondary_info) == 1:
+    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
+          new_data.append((new_coord, label, width, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, color, acous))
+
+  if len(main_info) == 3 and len(secondary_info) == 2:
+    for coords, label, width, color, acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, color, acous, fire))
+
+  if len(main_info) == 4 and len(secondary_info) == 1:
+    for coords, label, width, height, color, acous in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, height, color, acous))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, height, color, acous))
+
+  if len(main_info) == 4 and len(secondary_info) == 2:
+    for coords, label, width, height, color,  acous, fire in locations:
+        if len(coords)>1:
+          index = processed[label] % len(coords)  # Round-robin indexing
+          new_coord = [coords[index]]  # Pick the correct coordinate
+          new_data.append((new_coord, label, width, height, color, acous, fire))
+          processed[label] += 1  # Move to the next coordinate for this label
+        if len(coords)==1:
+          new_data.append((coords, label, width, height, color, acous, fire))
+
+  return new_data
+
+from collections import defaultdict
+
+def get_cleaned_data_gpt(locations):
+    processed = defaultdict(int)
+    new_data = []
+
+    for entry in locations:
+        coords = entry[0]
+        label = entry[1]
+        index = processed[label] % len(coords) if len(coords) > 1 else 0
+        new_coord = [coords[index]] if len(coords) > 1 else coords
+        processed[label] += 1 if len(coords) > 1 else 0
+
+        # Rebuild the entry with updated coordinates
+        new_entry = (new_coord,) + entry[1:]
+        new_data.append(new_entry)
+
+    return new_data
+
+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 acous, fire 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)):
+    newest_text = f"{widths[i]}; {secondary_printed_clean[i]}"
+    all_print.append(newest_text) 
+  return all_print
+
+def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, secondary_info):
+    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
+    if len(main_info) == 2 and len(secondary_info) == 1:
+        for loc in locations:
+            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)
+                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(main_info) == 2 and len(secondary_info) == 2:
+        for loc in locations:
+            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)
+                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(main_info) == 3 and len(secondary_info) == 1:
+        for loc in locations:
+            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)
+                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(main_info) == 3 and len(secondary_info) == 2:
+        for loc in locations:
+            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)
+                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(main_info) == 4 and len(secondary_info) == 1:
+        for loc in locations:
+            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)
+                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(main_info) == 4 and len(secondary_info) == 2:
+        for loc in locations:
+            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)
+                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:
+        user_input.append(item[0])
+    return user_input
+
+def modify_author_in_pypdf2(pdf_bytes, new_authors):
+    pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
+    reader = PyPDF2.PdfReader(pdf_stream)
+    writer = PyPDF2.PdfWriter()
+
+    author_index = 0  # Track author assignment
+
+    for page in reader.pages:
+        if "/Annots" in page:  #Check if annotations exist
+            for annot in page["/Annots"]:
+                annot_obj = annot.get_object()
+                # Assign each annotation a unique author
+                if len(new_authors) == 0:
+                    break
+                if author_index < len(new_authors):
+                    annot_obj.update({"/T": TextStringObject(new_authors[author_index])})#Convert to PdfString
+                    author_index += 1  # Move to next author
+
+                # If authors list is exhausted, keep the last one
+                else:
+                    annot_obj.update({"/T": TextStringObject(new_authors[-1])})
+
+        writer.add_page(page)
+
+    #Save the modified PDF to a variable
+    output_stream = io.BytesIO()
+    writer.write(output_stream)
+    output_stream.seek(0)
+
+    return output_stream.read()
+
+    # return output_stream.getvalue()  # Return modified PDF as bytes
+
+def process_pdf_secondary(input_pdf_path, output_pdf_path, locations, new_authors, main_info, secondary_info):
+
+    #Add Bluebeam-compatible count annotations
+    annotated_pdf_bytes = add_bluebeam_count_annotations_secondary(input_pdf_path, 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
+
 import fitz  # PyMuPDF
 import PyPDF2
 import io
 from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
 
-def add_bluebeam_count_annotations(pdf_bytes, locations,pdf_content=0):
-    if pdf_content:
-       pdf_document = fitz.open(stream=pdf_content, filetype="pdf")
-    else:
-      pdf_stream = io.BytesIO(pdf_bytes)  # Load PDF from bytes
-      pdf_document = fitz.open("pdf", pdf_stream.read())  # Open PDF in memory
+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
     if len(locations[0]) == 3:
@@ -607,16 +1136,13 @@ def merge_pdf_bytes_list(pdfs):
 
     return output_stream.read()
 
-def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors,pdf_content=0):
+def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     #Load original PDF
     # with open(input_pdf_path, "rb") as file:
     #     original_pdf_bytes = file.read()
 
     #Add Bluebeam-compatible count annotations
-    if pdf_content:
-      annotated_pdf_bytes = add_bluebeam_count_annotations(input_pdf_path, locations,pdf_content)
-    else:
-       annotated_pdf_bytes = add_bluebeam_count_annotations(input_pdf_path, locations)
+    annotated_pdf_bytes = add_bluebeam_count_annotations(input_pdf_path, locations)
 
     #Modify author field using PyPDF2
     final_pdf_bytes = modify_author_in_pypdf2(annotated_pdf_bytes, new_authors)
@@ -625,69 +1151,81 @@ def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors,pdf_cont
     # with open(output_pdf_path, "wb") as file:
     #     file.write(final_pdf_bytes)
         
-def mainRun(schedule, plan, searcharray,pdf_content=0,schedule_content=0):
+def mainRun(schedule, plan, searcharray):
   #print(type(plan))
-  if pdf_content==0:
-    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}")
+  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)
-  if schedule_content:
-    dfs = extract_tables(schedule,schedule_content)
-  else:
-     dfs = extract_tables(schedule)
-    
-  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)
-      if pdf_content:
-        plan_texts = read_text(p,pdf_content)
-      else:
-         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)
-      if pdf_content:
-        final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths,pdf_content)
-      else:
-         final_pdf_bytes = process_pdf(p, "final_output_width.pdf", new_data, widths)
-      pdfs.append(final_pdf_bytes)
+  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_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)
       
-        
+      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)
+          
 
-    
-  #plan_texts = read_text(plan)
-  #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)
+  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 = []
-      #for j in range(len(locations)):
-      #    widths.append("Dimensions not found in schedule")
-  #final_pdf_bytes= process_pdf(plan, "final_output_width.pdf", new_data, 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 = []