Update google_sheet_Legend.py

google_sheet_Legend.py

@@ -17,8 +17,13 @@ from google.oauth2 import service_account
 from googleapiclient.discovery import build
 import pygsheets
 import tsadropboxretrieval
+import requests
 import fitz
 import numpy as np
+from PyPDF2 import PdfReader, PdfWriter
+from io import BytesIO
+from PyPDF2.generic import NameObject, DictionaryObject, FloatObject, TextStringObject
+import dropbox
 
 
 def authorizeLegend():
@@ -33,9 +38,13 @@ def authorizeLegend():
   gc = pygsheets.authorize(custom_credentials=credentials, client_secret='credentials.json')
   return spreadsheet_service,drive_service,gc
 
+#########################
+global gc
+global pdfpath0
+global pdftitle
+global worksheetw
 spreadsheet_service,drive_service,gc=authorizeLegend()
-
-
+#########################
 def create_new_sheet(path):
     spreadsheet_details = {
         'properties': {
@@ -51,9 +60,11 @@ def create_new_sheet(path):
     drive_service.permissions().create(fileId=spreadsheetId, body=permission1, supportsAllDrives=True).execute()
     return spreadsheetId
 
-
+#########################
 def update_sheet(spreadsheetId, SimilarAreaDictionary, pdfpath):
     ws = gc.open_by_key(spreadsheetId)
+    global pdfpath0
+    pdfpath0=pdfpath
     worksheet = ws.worksheet(0)
     worksheet.title = 'Legend and data created'
     worksheet.clear()
@@ -252,15 +263,19 @@ def update_sheet(spreadsheetId, SimilarAreaDictionary, pdfpath):
     model_cell.color = (213 / 255, 219 / 255, 255 / 255)
     pygsheets.DataRange('A2', 'K2', worksheet=worksheet).apply_format(model_cell)
 
-
+#########################
 def legendGoogleSheets(SimilarAreaDictionary, path, pdfpath, spreadsheetId=0):
     titles = gc.spreadsheet_titles()
     if path in titles:
         ws = gc.open(path)
+        global pdftitle
+        pdftitle=path
         spreadsheetId = ws.id
     else:
         spreadsheetId = create_new_sheet(path)
         ws=gc.open_by_key(spreadsheetId)
+    global worksheetw
+    worksheetw = ws.worksheet(0) #legend
     update_sheet(spreadsheetId, SimilarAreaDictionary, pdfpath)
     spreadsheet_url = f"https://docs.google.com/spreadsheets/d/{spreadsheetId}"
     drive_service.permissions().update(transferOwnership=True, fileId=spreadsheetId, permissionId='11OfoB4Z6wOVII8mYmbnCbbqTQs7rYA65')
@@ -268,9 +283,8 @@ def legendGoogleSheets(SimilarAreaDictionary, path, pdfpath, spreadsheetId=0):
     namepathArr = [path, spreadsheetId, ws.get_developer_metadata('path')[0].value]
     return gc, spreadsheet_service, spreadsheetId, spreadsheet_url, namepathArr
 
-#######################
-
-def mapnametoLegend(McTName): 
+#########################
+def mapnametoLegend(McTName,colorsused,pdflink): 
 
   sectionKey = McTName.pop()
   key=sectionKey[0]
@@ -280,37 +294,38 @@ def mapnametoLegend(McTName):
   spreadsheet_key =str(key)  # Please set the Spreadsheet ID.
   
   ws = gc.open_by_key(spreadsheet_key)
+  
   # guessednamesfinal=getguessnames(gc,ws)
   sheetnames=[]
   unit=''
   # ws.add_worksheet("Summary")  # Please set the new sheet name.
   for i in ws._sheet_list:
-    print(i)
+    # print(i)
     sheetnames.append(i.title)
-    print(i.index)
+    # print(i.index)
   if 'XML Export Summary' in sheetnames:
     worksheetS = ws.worksheet_by_title('XML Export Summary')
   else:
     ws.add_worksheet("XML Export Summary")  # Please set the new sheet name.
+  global worksheetw
   worksheetw = ws.worksheet(0) #legend
   worksheetS = ws.worksheet_by_title('XML Export Summary')
   summaryId= ws[1].id
-  print('summaryyyID',summaryId)
-  print('summaryyyID2',worksheetS.id)
+  
   worksheetS.clear()
 
   countnames=0
   row0=['MC_T Name','Qty','Unit']
   worksheetS.update_row(1,row0)
   
-  
+  allrows=[]
   for i in range(len(McTName)):
     allgbnames=''
     item=''
-    print(McTName[i][0])
+
     
     # firstpart= re.split(r'[`\-=~!@#$%^&*()_+\[\]{};\'\\:"|<,./<>?]', McTName[i][0])
-    print('kkk' ,McTName[i][2])
+    # print('kkk' ,McTName[i][2])
     if McTName[i][2].startswith('Area'):
       if section.startswith('1.0') or section.startswith('3.2') or section.startswith('3.3'):
         rowvalue=5# column 5 
@@ -333,7 +348,6 @@ def mapnametoLegend(McTName):
       ar=0   
       unit='Nr'
  
-    print('mcct',McTName[i][1])
     if isinstance(McTName[i][1], list):
       guessednames=worksheetw.get_col(1, returnas='matrix', include_tailing_empty=False)
 
@@ -341,9 +355,10 @@ def mapnametoLegend(McTName):
         if m:
           if m.startswith('text1'):
             name=m.removeprefix('text1')
-            allgbnames+= name +' +'
+
+            allgbnames+= name +' + '
             indices = [o for o, x in enumerate(guessednames) if x == name]
-            print(indices)
+            # print(indices)
             for j in range(len(indices)):
               # print('kjjjj',roww[j])
               ar+=float(worksheetw.cell((indices[j]+1 ,rowvalue)).value) 
@@ -352,7 +367,7 @@ def mapnametoLegend(McTName):
                 item+=m
               else: 
                 item+=m + ' ,'
-              print(item)
+              # print(item)
           if section.startswith('3.2') or section.startswith('3.3'):
             n= McTName[i][0] + ' ( '+ allgbnames[:-2]+ ' )  '
           else:
@@ -363,19 +378,25 @@ def mapnametoLegend(McTName):
         allgbnames+= name
 
         roww=worksheetw.find(name)
-        print(roww)
         for j in range(len(roww)):
-          print('kjjjj',roww[j])
+          # print('kjjjj',roww[j])
           ar+=float(worksheetw.cell((roww[j].row ,rowvalue)).value) 
         n= McTName[i][0] + ' ( '+ allgbnames + ' )  ' 
 
     rowi=[str(n),ar,unit]
+
+    allrows.append([rowi[0],unit])
+    
     worksheetS.update_row(i+2,rowi)
     # worksheetS.adjust_column_width(start=1,end=4)
     worksheetS.adjust_column_width(start=1,end=1, pixel_size=350)
     worksheetS.adjust_column_width(start=2,end=2, pixel_size=100)
     worksheetS.adjust_column_width(start=3,end=3)
-    
+  guessednamesfinal=getguessnames(worksheetw,colorsused) #gb,color
+  mctname_guessedNames=label_MC_Tname(allrows) #mctname, gb1
+  mappedMct_colors=mctname_colors(guessednamesfinal,mctname_guessedNames) #mctname,gb1
+  adjustannotations(pdflink, mappedMct_colors)
+
   xx=(worksheetS.cell( ( len(McTName) +1 ,3)) ).address.label
   model_cell1 =worksheetS.cell('A2')
   model_cell1.set_horizontal_alignment( pygsheets.custom_types.HorizontalAlignment.LEFT )
@@ -461,18 +482,84 @@ def mapnametoLegend(McTName):
 
   # print(x,xarea)
 
-def getguessnames(gc,ws):
+#########################
+def label_MC_Tname(mctname_names):
+  # print('mctname_names',mctname_names)
+  mctname_guessedNames=[]
+  # unit=mctname_names[1]
+  for row in mctname_names:
+    text=row[0]
+    unit=row[1]
+    # print(text,unit)
+    text_before_parenthesis = text.split('(')[0].strip()
+    # Step 2: Extract text inside the parentheses
+    inside_parentheses = re.search(r'\((.*?)\)', text)
+    if inside_parentheses:
+        inside_parentheses = inside_parentheses.group(1).strip()
+        if '+' in inside_parentheses:
+            # Split the content by '+', and strip any leading/trailing spaces
+            parts = [part.strip() for part in inside_parentheses.split('+')]
+        else:
+            # If no '+', just put the whole content as a single part
+            parts = [inside_parentheses]
+        mctname_guessedNames.append([text_before_parenthesis,parts , unit])
+        # print('mctname_guessedNames',mctname_guessedNames)
+  return mctname_guessedNames  
+  
+#########################
+def mctname_colors(color_dict, mctname_gb):
+    
+    # print('color_dict', color_dict)
+    # print('mctname_gb', mctname_gb)
+
+    # Convert the color_dict array into a dictionary with trimmed keys for easier lookup
+    color_dict_map = {color[0].strip(): color[1] for color in color_dict}
+    # print('color_dict_map', color_dict_map)
+
+    # Result list to store the final output
+    result = []
+
+    # Processing the items
+    for item in mctname_gb:
+        name = item[0]
+        colors = item[1]
+        unit=item[2]
+        # print(name,colors)
+        # Get RGB values for the corresponding colors
+        color_values = []
+        for color in colors:
+            trimmed_color = color.strip()  # Trim any leading/trailing spaces
+            if trimmed_color in color_dict_map:
+                color_values.append(color_dict_map[trimmed_color])
+            else:
+                # Handle missing references (e.g., append None or a default color)
+                color_values.append(None)  # Or append a default color like (0, 0, 0)
+
+        # Join the name with the corresponding RGB colors
+        result.append([name, color_values,unit])
+
+    # Print the result
+    # print('result', result)
+    return result
+
+
+
+#########################
+def getguessnames(worksheetw,colorsused):
   guessednamesfinal=[]
-  worksheetw = ws.worksheet(0)
+  # print('colorsused',colorsused)
   guessednames=worksheetw.get_col(1, returnas='matrix', include_tailing_empty=False)
-  print(guessednames[2:])
-  for item in guessednames[2:]:
-     if item not in guessednamesfinal:
-        guessednamesfinal.append(item)
-  print(guessednamesfinal)
+  # print(guessednames)
+  for i in range(len(guessednames[3:])):
+      item = guessednames[3:][i]  # Name from the guessednames list
+
+      colorforitem = colorsused[i]  # Get the corresponding color for the current item      
+      if item not in guessednamesfinal:
+          guessednamesfinal.append([item, colorforitem]) 
+  # print('guessednamesfinal', guessednamesfinal)
   return guessednamesfinal
 
-################################################################
+#########################
 def is_color_within_tolerance(color1, color2, tolerance):
     # Ensure both colors are tuples of integers
     color1 = tuple(map(int, color1))
@@ -480,12 +567,14 @@ def is_color_within_tolerance(color1, color2, tolerance):
     
     return all(abs(c1 - c2) <= tolerance for c1, c2 in zip(color1, color2))
 
+#########################
 def deletefromlegend(deletedrows, SimilarAreaDictionarycopy, section, areaPermArr=[]):
     items = []
-    print('deletefromlegend',deletedrows)
+    # print('deletefromlegend',deletedrows)
     idx = 0
     if section.startswith('1.0') or section.startswith('3.2') or section.startswith('3.3'):
         areaPermArr = ast.literal_eval(areaPermArr)
+        print(areaPermArr)
     myDict = eval(SimilarAreaDictionarycopy)
     SimilarAreaDictionarycopy = pd.DataFrame(myDict)
     strings = deletedrows['content']
@@ -512,22 +601,19 @@ def deletefromlegend(deletedrows, SimilarAreaDictionarycopy, section, areaPermAr
                
             # print('eee',existing_color,color)
             if is_color_within_tolerance(existing_color, color, tolerance):
-                print(f'Color {color} found close to {existing_color} at index {idx}')
+                # print(f'Color {color} found close to {existing_color} at index {idx}')
                 found = True
-                # print(strings[j])
+                # print('strings',strings[j])
                 matchA = re.search(r"Area=(\d+\.\d+)", strings[j])
                 matchP = re.search(r"Perimeter=(\d+\.\d+)", strings[j])
                 matchL = re.search(r"Length=(\d+\.\d+)", strings[j])
-                if matchA:
-                  print('matchingcontentAA ',float(matchA.group(1)),int(idx))
-                if matchP:
-                   print('matchingcontentPP ',float(matchP.group(1)),int(idx))
+
                 comment = SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Comments')]
                 occ = SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Occurences')]
 
                 # Only subtract area if the area value is found
                 if matchA:
-                    print(' SimilarAreaDictionaryArea',  float(matchA.group(1)),   SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Total Area')])
+                    # print(' SimilarAreaDictionaryArea',  float(matchA.group(1)),   SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Total Area')])
                     SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Total Area')] =SimilarAreaDictionarycopy.iloc[int(idx), SimilarAreaDictionarycopy.columns.get_loc('Total Area')] - float(matchA.group(1))
                     # Update area occurrences
                     if pd.notna(comment) and 'Area' in str(comment):
@@ -583,14 +669,13 @@ def deletefromlegend(deletedrows, SimilarAreaDictionarycopy, section, areaPermAr
 
         if not found:
             print(f'Color {color} not found within tolerance')
-    print('indicies_toDelete',indicies_toDelete)
+    # print('indicies_toDelete',indicies_toDelete)
 
     SimilarAreaDictionarycopy.drop(index=indicies_toDelete, axis=0, inplace=True)
-    print('SimilarAreaDictionarycopy',SimilarAreaDictionarycopy)
+    # print('SimilarAreaDictionarycopy',SimilarAreaDictionarycopy)
     return SimilarAreaDictionarycopy
 
-
-
+#########################
 def DoorsLegend(Dictionary,spreadsheetId,worksheet):
     top_header_format = [
             {'mergeCells': {  # legend and data created
@@ -683,11 +768,12 @@ def DoorsLegend(Dictionary,spreadsheetId,worksheet):
     model_cell.set_horizontal_alignment(pygsheets.custom_types.HorizontalAlignment.CENTER)
     model_cell.color = (213 / 255, 219 / 255, 255 / 255)
     pygsheets.DataRange('A2', 'B2', worksheet=worksheet).apply_format(model_cell)
+#########################
 
 def delete3_2(deletedrows,dictionary):
 
   items=[]
-  print('dletefromlegend3.2')
+  # print('dletefromlegend3.2')
   idx=0
   myDict=eval(dictionary)
   df_doors=pd.DataFrame(myDict)
@@ -720,8 +806,7 @@ def delete3_2(deletedrows,dictionary):
   df_doors = df_doors[['Type', 'Quantity']]
   return df_doors
 
-######################
-
+#########################
 
 def deletemarkups(list1, dbPath, path):
     '''list1 : original markup pdf
@@ -765,7 +850,7 @@ def deletemarkups(list1, dbPath, path):
     # Find the deleted rows by checking the difference between original and current annotations
     deletedrows = pd.concat([list1, list2]).drop_duplicates(keep=False)
 
-    print(deletedrows, len(deletedrows))
+    # print(deletedrows, len(deletedrows))
     flag = 0
     if len(deletedrows) != 0:
         flag = 1
@@ -775,4 +860,104 @@ def deletemarkups(list1, dbPath, path):
     else:
         flag = 0
     
-    return deletedrows
+    return deletedrows
+
+############################
+
+
+def adjustannotations(pdflink, color_items):
+    # Load the input PDF
+  pdf_content = None
+  if pdflink and ('http' in pdflink or 'dropbox' in pdflink):
+    # Modify Dropbox link for direct download
+    # print('pdffff',pdflink)
+    if 'dl=0' in pdflink:
+      pdflink = pdflink.replace('dl=0', 'dl=1')
+
+      # Download the PDF content from the shareable link
+      response = requests.get(pdflink)
+      pdf_bytes_io = BytesIO(response.content)  # Store the content in memory
+      # pdf_bytes_io = BytesIO(OutputPdfStage1)
+      reader = PdfReader(pdf_bytes_io)
+      writer = PdfWriter()
+
+      # Append all pages to the writer
+      writer.append_pages_from_reader(reader)
+
+      # Add metadata (optional)
+      metadata = reader.metadata
+      writer.add_metadata(metadata)
+
+      # Convert color_items array to a more accessible structure (a dictionary of colors)
+      color_dict = {}
+      for item in color_items:
+          label = item[0]
+          colors = item[1]
+          unit = item[2]
+          # print('UNIT', unit)
+          for color in colors:
+              color_dict[tuple(color)] = (label, unit)  # Map RGB color to a tuple (label, unit)
+
+      # print(color_dict)
+
+      # Iterate over pages to check annotations and update label
+      for page_index, page in enumerate(writer.pages):
+          if "/Annots" in page:
+              annotations = page["/Annots"]
+              for annot_index, annot in enumerate(annotations):
+                  obj = annot.get_object()
+
+                  # Only proceed if the annotation has a color and is a valid markup (e.g., Polygon)
+                  if "/C" in obj:
+                      color = tuple(obj["/C"])  # Extract the RGB color (list of 3 values)
+                      color = (int(round(color[0] * 255, 1)), int(round(color[1] * 255, 1)), int(round(color[2] * 255, 1)))
+
+                      # If the color matches any item in color_dict, update the label
+                      if color in color_dict:
+                          label, unit = color_dict[color]  # Retrieve both label and unit
+                          # print(unit)
+                          # Update annotation label (e.g., /Contents or /Subj)
+                          if "/Contents" in obj:
+                              if unit == 'm2' and "sq m" in obj["/Contents"]:
+                                  obj.update({
+                                      NameObject("/Label"): TextStringObject(f"{label}")
+                                  })
+                              elif unit == 'm' and "m" in obj["/Contents"] and "sq" not in obj["/Contents"]:  # Ensure it's not an area
+                                  obj.update({
+                                      NameObject("/Label"): TextStringObject(f"{label}")
+                                  })
+                          # print(f"Updated Annotation: {obj}")
+
+     # Save the modified PDF
+      output_pdf_io = BytesIO()
+      writer.write(output_pdf_io)
+      output_pdf_io.seek(0)
+
+      # Save the content to a file (avoid using the same name for the variable and file object)
+      OutputPdfStage2=output_pdf_io.read()
+      doc2 =fitz.open('pdf',OutputPdfStage2)
+      dbPath='/TSA JOBS/ADR Test'+pdfpath0+'Measured Plan/'+pdftitle
+      # dburl=tsadropboxretrieval.uploadanyFile(doc=doc2,pdfname=pdftitle ,path=dbPath)
+      # print('omarpdf',dburl)
+      print("Annotations updated and saved")
+      dbxTeam= tsadropboxretrieval.ADR_Access_DropboxTeam('user')
+      try:
+          # Upload the new file and overwrite the existing one
+          dbxTeam.files_upload(doc2.write() ,dbPath, mode=dropbox.files.WriteMode('overwrite'))
+              # dbxTeam.files_upload(f.read(), dropbox_file_path, mode=dropbox.files.WriteMode('overwrite'))
+          print(f"File replaced successfully at")
+      except dropbox.exceptions.ApiError as e:
+          print(f"Error replacing the file: {e}")
+      # return dburl
+
+def getallguessednames():
+    guessednamesfinal = []
+    # Retrieve column data from the worksheet
+    global worksheetw
+    guessednames = worksheetw.get_col(1, returnas='matrix', include_tailing_empty=False)
+    # Skip the first three entries and filter out empty/whitespace strings
+    for item in guessednames[3:]:
+        if item.strip() and item not in guessednamesfinal:  # Remove surrounding whitespace and check for uniqueness
+            guessednamesfinal.append(item)
+    print('guessednamesfinal:', guessednamesfinal)
+    return guessednamesfinal