Update Doors_Schedule.py

Doors_Schedule.py

@@ -221,14 +221,13 @@ def get_selected_columns(dfs, user_patterns):
     cell_matches, col_matches = analyse_cell_columns(cell_columns_appearance)
 
    
-    #clmn_name = map_user_input_to_standard_labels(user_patterns)
-    #if len(clmn_name) < len(user_patterns):
+
     if len(user_patterns) == 2:
       clmn_name = ["door_id", "door_type"] 
     if len(user_patterns) == 4:
       clmn_name = ["door_id", "door_type", "width", "height"]
     if len(user_patterns) == 3:
-        clmn_name = ["door_id", "door_type", "structural_opening"]
+        clmn_name = ["door_id", "door_type", "structural opening"]
     if len(cell_matches) == 0 and len(col_matches) == 0:
       print(f"this is df {i}, SEARCH IN ANOTHER DF")
     else:
@@ -236,13 +235,11 @@ def get_selected_columns(dfs, user_patterns):
       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])
@@ -258,7 +255,6 @@ def get_selected_columns(dfs, user_patterns):
           #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)")
@@ -266,62 +262,19 @@ def get_selected_columns(dfs, user_patterns):
           break
   return selected_columns_new
 
-'''def get_st_op_pattern(clm_idx, clmn_name, starting_row_index,df):
-  target = 'structural opening'
-  clm_dict = dict(clm_idx)  # Convert list of tuples to dictionary
-  structural_opening_value = clm_dict.get(target)  # Returns None if not found
-
-  if target in clmn_name:
-    position = clmn_name.index(target)
-    kelma = df.iloc[starting_row_index[position], structural_opening_value]
-  else:
-    kelma = None
-  return kelma'''
-
-'''def get_st_op_pattern(clmn_name):
-    target = 'structural opening'
-    for name in clmn_name:
-        if target in name.lower():
-            return name
-    return None'''
 
 
 # 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
     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': []})
-
-  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:
-        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_similar_colors(selected_columns_new):
   def generate_rgb():
@@ -466,15 +419,6 @@ def get_cleaned_data(locations):
 
   return new_data
 
-'''def get_width_info_tobeprinted(new_data):
-  width_info_tobeprinted = []
-  if len(new_data[0]) == 4:
-    for _,_,_, w in new_data:
-      width_info_tobeprinted.append(w)
-  if len(new_data[0]) == 5:
-    for _,_,_, w,h in new_data:
-      width_info_tobeprinted.append(f"{w} mm wide x {h} mm high")
-  return width_info_tobeprinted'''
 
 def get_width_info_tobeprinted(new_data):
   width_info_tobeprinted = []
@@ -637,6 +581,23 @@ def modify_author_in_pypdf2(pdf_bytes, new_authors):
 
     # return output_stream.getvalue()  # Return modified PDF as bytes
 
+from PyPDF2 import PdfReader, PdfWriter
+
+def merge_pdf_bytes_list(pdfs):
+    writer = PdfWriter()
+
+    for pdf_bytes in pdfs:
+        pdf_stream = io.BytesIO(pdf_bytes)
+        reader = PdfReader(pdf_stream)
+        for page in reader.pages:
+            writer.add_page(page)
+
+    output_stream = io.BytesIO()
+    writer.write(output_stream)
+    output_stream.seek(0)
+
+    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:
@@ -653,37 +614,64 @@ def process_pdf(input_pdf_path, output_pdf_path, locations, new_authors):
     #     file.write(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)
   dfs = extract_tables(schedule)
-  #selected_columns = get_selected_columns(dfs)
+    
   selected_columns_new = get_selected_columns(dfs, user_input)
-  #selected_columns_new = selected_columns[0][0]
-  #df = selected_columns[0][1]
-  #clm_idx = selected_columns[0][2]
-  #clmn_name = selected_columns[0][3]
-  #starting_row_index = selected_columns[0][4]
-  #kelma = get_st_op_pattern(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)
-  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)
+
+  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)
+      
+        
+
+    
+  #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)
   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)
-  
-  
-  doc2 =fitz.open('pdf',final_pdf_bytes)
+  #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 = []
+  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)