Update Doors_Schedule.py

Doors_Schedule.py

@@ -433,6 +433,91 @@ def get_selected_columns_all(dfs, user_patterns):
           #break
   return selected_columns_new
 
+#for new dictionary logic
+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)):
+
+
+
+    extra_info = user_patterns[6:]
+
+    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
+    clmn_name = clmn_name_main + clmn_name_secondary + extra_info
+
+    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}")
+    print(f"col_matches: {col_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)
+        print(f"column names: {clmn_name}")
+        print(f"column index list: {column_index_list}")
+        selected_columns_new = details_in_another_table(clmn_name, column_index_list, dfs[i], dfs)
+        selected_columns_new2 = crop_rename_table(row_index_list, clmn_name, column_index_list,dfs[i])
+        selected_columns_new =  pd.concat([selected_columns_new, selected_columns_new2], ignore_index=True)
+        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)
@@ -1308,6 +1393,179 @@ def create_bb_bax(new_data, widthat, heightat, CountStyles, page_number, height_
   return bax_annotations
 
 
+def add_location(col_dict, plan_texts):
+  not_found = []
+  for key_outer, value_outer in col_dict.items():
+    locations = []
+    for id in value_outer['door_id']:
+      location, _,_ = find_text_in_plan(id, plan_texts)
+      if len(location) == 0:
+        not_found.append(id)
+      locations.append(location)
+      value_outer['location'] = locations
+  return col_dict, not_found
+
+import pandas as pd
+
+def _ensure_color_tuple(x):
+    if x is None or isinstance(x, tuple):
+        return x
+    try:
+        return tuple(x)
+    except Exception:
+        return x
+
+def _ensure_list_of_tuples(val):
+    if val is None:
+        return []
+    if isinstance(val, tuple):
+        return [val]
+    if isinstance(val, list):
+        out = []
+        for item in val:
+            if item is None:
+                continue
+            if isinstance(item, tuple):
+                out.append(item)
+            elif isinstance(item, list):
+                out.append(tuple(item))
+            else:
+                try:
+                    out.append(tuple(item))
+                except Exception:
+                    pass
+        return out
+    try:
+        return [tuple(val)]
+    except Exception:
+        return []
+
+def grouped_to_dataframe_dynamic(grouped, keep_group=False,
+                                 explode_locations=False,
+                                 drop_empty_locations=False):
+    rows = []
+
+    for group_key, block in grouped.items():
+        ids = block.get('door_id') or block.get('values') or []
+        list_lengths = [len(v) for v in block.values() if isinstance(v, list)]
+        n = max(list_lengths + [len(ids)]) if (list_lengths or ids) else 0
+        if n == 0:
+            continue
+
+        for i in range(n):
+            row = {}
+            door_id = ids[i] if i < len(ids) else f"{group_key}:{i}"
+            row['door_id'] = door_id
+
+            for k, v in block.items():
+                if k == 'values':
+                    continue
+                val = (v[i] if isinstance(v, list) and i < len(v)
+                       else (v if not isinstance(v, list) else None))
+                if k == 'color':
+                    val = _ensure_color_tuple(val)
+                elif k == 'location':
+                    val = _ensure_list_of_tuples(val)
+                row[k] = val
+
+            if keep_group:
+                row['source_group'] = group_key
+            rows.append(row)
+
+    df = pd.DataFrame(rows)  # dynamic union of keys
+
+    # If there's a 'location' column, normalize + optionally drop empties / explode
+    if 'location' in df.columns:
+        df['location'] = df['location'].apply(_ensure_list_of_tuples)
+
+        if drop_empty_locations:
+            df = df[df['location'].map(lambda xs: len(xs) > 0)].reset_index(drop=True)
+
+        if explode_locations:
+            # after filtering empties, explode so each row has a single (x,y) tuple
+            df = df.explode('location', ignore_index=True)
+
+    return df
+
+# Modify it to return widths and height from width, height columns
+def get_width_clean_width_height(width_list, height_list):
+  widths = []
+  heights = []
+  for width in width_list:
+    w = re.sub(r",", "", width)
+    if is_not_number(w):
+      w = w
+    else:
+      if float(w).is_integer():
+        w = int(float(w))
+      else:
+        w = w
+    w = str(w)
+    widths.append(w)
+  for height in height_list:
+    h = re.sub(r",", "", height)
+    if is_not_number(h):
+      h = h
+    else:
+      if float(h).is_integer():
+        h = int(float(h))
+      else:
+        h = h
+    h = str(h)
+    heights.append(h)
+  return widths, heights
+
+def get_widths_bb_format_st_op(cleaned_width, kelma):
+  pattern = r"\bW(?:idth)?\s*[×x]\s*H(?:eight)?\b"
+  match = re.search(pattern, kelma)
+  widths = []
+  heights = []
+  for widthaa in cleaned_width:
+    index = max(widthaa.find("x"), widthaa.find("×"), widthaa.find("x"), widthaa.find("X"), widthaa.find("x"))
+    width_name = widthaa[:index]
+    height_name = widthaa[index+1:]
+    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"
+      width = width_name
+      height = height_name
+    else:
+      width = height_name
+      height = width_name
+    widths.append(width)
+    heights.append(height)
+  return widths, heights
+
+# New for new dictionary logic
+def create_bb_bax_new(df_points, CountStyles, page_number, height_plan):
+  bax_annotations = []
+  exclude = {"location", "color"}
+  for _, row in df_points.iterrows():
+    rw = row
+    customDta = row.drop(labels=exclude, errors="ignore").to_dict()
+    r,g,b = rw['color']
+    R = str(float(r/255))
+    G = str(float(g/255))
+    B = str(float(b/255))
+    x, y = rw['location']
+    vertix = point_mupdf_to_pdf(x, y, height_plan)
+    bax_annotations.append({
+          'vertices': vertix,
+          'text': '1', #number of counts in one time (in markup written as count 1) -> if u want to change it we can look for a way
+          'author': 'ADR',
+          'custom_data': customDta, #identify custom colums here as( Column name: Text to add )
+          'label': rw['door_id'], #change label to whatever u want
+          'page' : page_number,
+          'color':R+ ' '+G + ' '+B,# normalized (RGB --> R/255 G/255 B/255)
+          'countstyle': CountStyles['Circle'],
+          'countsize':'0.8' #how big or small is the count icon
+      })
+
+
+  return bax_annotations, customDta
+
+
 #Handle missing widths or heights in some rows
 def generate_separate_dimensions(widths):
   widthat = []
@@ -1409,6 +1667,7 @@ def pick_approach(schedule, plan, searcharray, flag):
       if value == len(plan):
         not_found_any_plan.append(key)
     not_found_any_plan = [item for item in not_found_any_plan if item != "N/A"]
+
     return no_tables, not_found_any_plan
 
 def mainRun(schedule, plan, searcharray):
@@ -1434,7 +1693,7 @@ def mainRun(schedule, plan, searcharray):
       elif len(not_found_any_plan_model) < len(not_found_any_plan_normal):
         pick_model = True
         #print("choose not_found_any_plan_model")
-      else:
+      else: # law ad ba3d choose the older approach (fitz)
         pick_normal = True
         #print("choose any")
 
@@ -1524,50 +1783,66 @@ def mainRun(schedule, plan, searcharray):
                if secondary_presence:
                   main_info = main_info + [""]
                flattened_list = get_flattened_tuples_list_no_doortype(selected_columns_combined)
+              
+            
+            
             plan_texts = read_text(p)
 
-            if secondary_presence:
-                    locations, not_found = get_word_locations_plan_secondary(flattened_list,plan_texts, main_info, secondary_info)
-                    not_found_list.append(not_found)
-                    new_data3 = get_cleaned_data_secondary(locations,main_info,secondary_info)
-              
-                    repeated_labels = get_repeated_labels(locations)
-                    repeated_labels = list(repeated_labels)
-                    repeated_labels_list.append(repeated_labels)
-                    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)
-                    
-                    
-                    #Count type annotation
-                    widht_count, height_count = generate_separate_dimensions(widths)
-                    bax = create_bb_bax_secondary(new_data3, widht_count, height_count, secondary_tobeprinted, CountStyles, user_input, page_number, page)
-                    bax_annotations_all_inputs.append(bax)
-                    
-                                      
+
+            #locations, not_found = get_word_locations_plan_secondary(flattened_list,plan_texts, main_info, secondary_info)
+            #not_found_list.append(not_found)
+            #new_data3 = get_cleaned_data_secondary(locations,main_info,secondary_info)
+      
+            #repeated_labels = get_repeated_labels(locations)
+            #repeated_labels = list(repeated_labels)
+            #repeated_labels_list.append(repeated_labels)
+            col_dict, not_found = add_location(col_dict, plan_texts)
+            not_found_list.append(not_found)
+
+            df_points = grouped_to_dataframe_dynamic(col_dict,
+                                         drop_empty_locations=True,
+                                         explode_locations=True)
+            # handling no door type in the new dictionary logic
+            if 'color' not in df_points:
+              df_points['color'] = (0, 0, 255)
+            dupes = df_points['door_id'].value_counts()
+            repeated_ids = dupes[dupes > 1].index.to_list()
+            repeated_labels_list.append(repeated_ids)
+
+            if kelma:
+              lst_st_op = df_points["structural_opening"].tolist()
+              cleaned_st_op = get_cleaned_width(lst_st_op)
+              widths, heights = get_widths_bb_format_st_op(cleaned_st_op, kelma)
+              # remove a column (returns a new df)
+              df_points = df_points.drop(columns=['structural_opening'])
+
+              # add two columns (scalars, lists/arrays/Series of length len(df), or expressions)
+              df_points['width'] = widths          # e.g., a list/Series/np.array or a scalar
+              df_points['height'] = heights
             else:
-                locations, not_found = get_word_locations_plan(flattened_list,plan_texts)
-                not_found_list.append(not_found)
-                new_data = get_cleaned_data(locations)
-                if len(new_data) == 0:
-                    continue
-                repeated_labels = get_repeated_labels(locations)
-                repeated_labels = list(repeated_labels)
-                repeated_labels_list.append(repeated_labels)
-                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)
-                #count type annotation
-                widht_count, height_count = generate_separate_dimensions(widths)
-                bax = create_bb_bax(new_data, widht_count, height_count, CountStyles, page_number, page)
-                bax_annotations_all_inputs.append(bax)
-          
+              lst_width = df_points["width"].tolist()
+              lst_height = df_points["height"].tolist()
+              clean_widths, clean_height = get_width_clean_width_height(lst_width, lst_height)
+              df_points["width"] = clean_widths
+              df_points["height"] = clean_height
+            df_points = df_points.rename(columns={'width': 'Width_', 'height':'Height_'})
+            
+            #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)
+            
+            
+            #Count type annotation
+            #widht_count, height_count = generate_separate_dimensions(widths)
+            #bax = create_bb_bax_secondary(new_data3, widht_count, height_count, secondary_tobeprinted, CountStyles, user_input, page_number, page)
+            #bax_annotations_all_inputs.append(bax)
+            bax, customDta = create_bb_bax_new(df_points, CountStyles, page_number, page)
+            bax_annotations_all_inputs.append(bax)      
+                                      
+
         # if it is not byte type
         #pdfs_count_type.append(convert_to_bytes(p))
         pdfs_count_type.append(p)
@@ -1580,8 +1855,13 @@ def mainRun(schedule, plan, searcharray):
     for bax_ann in bax_annotations_all_inputs:
         bax_annotation.extend(bax_ann)
 
-    column_order = ['FireRating', 'AcousticRating', 'Height_', 'Width_']
-    
+    #column_order = ['FireRating', 'AcousticRating', 'Height_', 'Width_']
+    column_order = []
+    for key in customDta.keys():
+      column_order.append(key)
+
+
+
     ## Getting the not found in all plans
     flattened_not_found_list = [item for sublist in not_found_list for item in sublist]
     counts_not_found = Counter(flattened_not_found_list)