Update Doors_Schedule.py

Doors_Schedule.py

@@ -13,6 +13,13 @@ from PyPDF2 import PdfReader
 from PyPDF2.generic import TextStringObject
 import numpy as np
 import cv2
+from collections import defaultdict
+import random
+import fitz  # PyMuPDF
+import PyPDF2
+import io
+from PyPDF2.generic import TextStringObject  # ✅ Required for setting string values
+from PyPDF2 import PdfReader, PdfWriter
 
 
 def convert2img(path):
@@ -392,67 +399,6 @@ def get_st_op_pattern(selected_columns, user_input):
     return None
 
 
-
-
-def get_similar_colors(selected_columns_new):
-  def generate_rgb():
-      return (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))  # RGB tuple
-
-  unique_keys = selected_columns_new['door_type'].unique()
-  key_colors = {key: generate_rgb() for key in unique_keys}  # Assign a unique RGB color to each key
-
-  # Create dictionary storing values, colors, and widths
-  if 'structural_opening' in selected_columns_new.columns:
-      col_dict = defaultdict(lambda: {'values': [], 'color': None, 'widths': []})
-  else:
-      col_dict = defaultdict(lambda: {'values': [], 'color': None, 'widths': [], 'heights': []})
-      if selected_columns_new.shape[1] == 2:
-        col_dict = defaultdict(lambda: {'values': [], 'color': None})
-
-
-  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'])  # Add structural opening
-      else:
-        if selected_columns_new.shape[1] > 2:
-          col_dict[key]['widths'].append(row['width'])  # Assuming 'widht' is a typo for 'width'
-          col_dict[key]['heights'].append(row['height'])
-      col_dict[key]['color'] = key_colors[key]  # Assign the unique RGB color
-
-  # Convert defaultdict to a normal dictionary
-  col_dict = dict(col_dict)
-  return col_dict
-    
-def get_flattened_tuples_list(col_dict):
-    tuples_list = []
-
-    for key, values_dict in col_dict.items():
-        if 'heights' in values_dict and 'widths' in values_dict:
-            # Case: Both widths and heights present
-            tuples_list.append([
-                (value, width, height, values_dict["color"])
-                for value, width, height in zip(values_dict['values'], values_dict['widths'], values_dict['heights'])
-            ])
-        elif 'widths' in values_dict:
-            # Case: Only widths present
-            tuples_list.append([
-                (value, width, values_dict["color"])
-                for value, width in zip(values_dict['values'], values_dict['widths'])
-            ])
-        else:
-            # Case: Neither widths nor heights
-            tuples_list.append([
-                (value, values_dict["color"])
-                for value in values_dict['values']
-            ])
-
-    # Flatten the list of lists
-    flattened_list = [item for sublist in tuples_list for item in sublist]
-
-    return flattened_list
-
 def find_text_in_plan(label, x):
   substring_coordinates = []
   words = []
@@ -465,6 +411,8 @@ def find_text_in_plan(label, x):
       words.append(tpl[4])
   return substring_coordinates, words, point_list
 
+
+
 def get_word_locations_plan(flattened_list, plan_texts):
   locations = []
   not_found = []
@@ -592,142 +540,6 @@ def get_widths_bb_format(cleaned_width, kelma):
   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_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
   width_info_tobeprinted = []
@@ -773,51 +585,6 @@ def get_width_info_tobeprinted_secondary(new_data, main_info, secondary_info):
       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
@@ -874,9 +641,6 @@ def get_word_locations_plan_secondary(flattened_list, plan_texts, main_info, sec
   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))
@@ -995,44 +759,6 @@ def get_cleaned_data_secondary(locations, main_info, secondary_info):
 
   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 get_secondary_tobeprinted_clean(selected_secondary_info, secondary_tobeprinted, secondary_info):
   secondary_printed_clean = []
   if len(secondary_info) == 1:
@@ -1201,11 +927,6 @@ def add_bluebeam_count_annotations_secondary(pdf_bytes, locations, main_info, se
 
     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
@@ -1238,96 +959,10 @@ def modify_author_in_pypdf2(pdf_bytes, new_authors):
 
     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_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:
-        for loc in locations:
-            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(locations[0]) == 4:
-        for loc in locations:
-            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(locations[0]) == 5:
-        for loc in locations:
-            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 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
@@ -1404,11 +1039,6 @@ def add_bluebeam_count_annotations(pdf_bytes, locations):
     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
@@ -1441,9 +1071,7 @@ def modify_author_in_pypdf2(pdf_bytes, new_authors):
 
     return output_stream.read()
 
-    # return output_stream.getvalue()  # Return modified PDF as bytes
 
-from PyPDF2 import PdfReader, PdfWriter
 
 def merge_pdf_bytes_list(pdfs):
     writer = PdfWriter()
@@ -1460,20 +1088,6 @@ def merge_pdf_bytes_list(pdfs):
 
     return output_stream.read()
 
-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
-    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)
-    return final_pdf_bytes
-    # #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):
     
@@ -1506,6 +1120,7 @@ def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     #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("mainRun is RUNNING")