handling weird exif element

app.py

@@ -54,31 +54,28 @@ def decode_utf16_little_endian(binary_data):
         # print(f"Test:{binary_data.decode('utf-16-le')}")
         # print(f"Type:{type(binary_data)}")
         decoded_text = binary_data.decode("utf-16-le").rstrip("\x00")
-        return decoded_text
     except Exception as e:
-        return f"Error decoding UTF-16 LE: {e}"
+        decoded_text = "Encoded"
+    return decoded_text
 
 
+'''
 def get_exif(list_file_paths):
     metadata_all_file = {}
     df = pd.DataFrame()
     for file_path in list_file_paths:
         metadata = {}
+        metadata["name"] = file_path.split("/")[-1]
         print(file_path)
         try:
-            # file_path = file_path_.split("/")[-1]
-            # df = pd.DataFrame()
-            # df['file_name'] = [file_path]
-            # print(df)
-            # print("inside the tryin")
             image = Image.open(file_path)
             exifdata = image._getexif()
             if exifdata is not None:
-                # print(metadata)
+                print(len(exifdata.items()))
                 for tagid, value in exifdata.items():
                     # print(tagid, value)
                     # print(f"Value:{value}")
-                    tagname = TAGS.get(tagid, tagid)
+                    tagname = str(TAGS.get(tagid, tagid))
                     # value = exifdata.get(tagid)
                     # Handle binary data
                     if isinstance(value, bytes):
@@ -86,18 +83,101 @@ def get_exif(list_file_paths):
                         # print(f"Value bytes {type(value)}")
                         # print(f"Value str {decode_utf16_little_endian(value)}")
                         value = decode_utf16_little_endian(value)
-                    metadata[tagname] = value
+                    print(tagname)
+                    print(type(tagname))
+                    print(value)
+                    if type(tagname) is not str:
+                        print(">>>>>>>>>>>> here " + type(tagname))
+                        try:
+                            metadata[str(tagname)] = value
+                        except:
+                            try:
+                                metadata[repr(tagname)] = value
+                            except:
+                                pass
+                    else:
+                        metadata[tagname] = value
+                    """
+                    for key in metadata.keys():
+                        if type(key) is not str:
+                            try:
+                                metadata[str(key)] = metadata[key]
+                            except:
+                                try:
+                                    metadata[repr(key)] = metadata[key]
+                                except:
+                                    pass
+                            del metadata[key]
+                    """
                     # print(f"\t{metadata}")
-                new_row = {"name": file_path, **metadata}
-                df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
+                print(metadata)
+                print(pd.DataFrame([metadata]))
+                df = pd.concat([df, pd.DataFrame([metadata])], ignore_index=True)
+                # new_row = {"name": file_path, **metadata}
+                # df = pd.concat([df, pd.DataFrame([new_row])], ignore_index=True)
                 # metadata_all_file[file_path] = metadata
             else:
                 return "No EXIF metadata found."
         except Exception as e:
             return f"Error : {e}"
-    print(df)
-    df["name"] = df["name"].apply(lambda filepath: filepath.split("/")[-1])
-    print(df)
+        print(pd.concat([df, pd.DataFrame([metadata])], ignore_index=True))
+    print(f"FINAL DF \n \n \n {df}")
+    return df
+'''
+import pandas as pd
+from PIL import Image
+from PIL.ExifTags import TAGS
+
+
+def decode_utf16_little_endian(value):
+    try:
+        return value.decode("utf-16le").strip()
+    except:
+        return value  # Fallback to the original value if decoding fails
+
+
+def extract_particular_value_from_exif_file(metadata, tagname, value):
+    pass
+
+
+def get_exif(list_file_paths):
+    df = pd.DataFrame()
+
+    for file_path in list_file_paths:
+        metadata = {"name": file_path.split("/")[-1]}
+        print(file_path)
+
+        try:
+            image = Image.open(file_path)
+            exifdata = image._getexif()
+
+            if exifdata is not None:
+                for tagid, value in exifdata.items():
+                    tagname = TAGS.get(tagid, str(tagid))  # Ensure tagname is a string
+                    print(type(tagname))
+                    if isinstance(value, bytes):
+                        value = decode_utf16_little_endian(value)
+                    if isinstance(value, dict):
+                        # for subkey, subvalue in value.items():
+                        #     metadata[f"{tagname}_{subkey}"] = subvalue
+                        # else:
+                        #     metadata[tagname] = value
+                        value = str(value)
+                    print(value)
+                    print(type(value))
+                    metadata[tagname] = value  # All keys are now strings
+                    print(metadata)
+                if all(isinstance(k, str) for k in metadata.keys()):
+                    df = pd.concat([df, pd.DataFrame([metadata])], ignore_index=True)
+                else:
+                    print("Skipping metadata with non-string keys.")
+            else:
+                print(f"No EXIF metadata found for {file_path}")
+
+        except Exception as e:
+            print(f"Error processing {file_path}: {e}")
+
+    print(f"FINAL DF:\n{df}")
     return df
 
 
@@ -127,7 +207,6 @@ def get_annotation(files_):
     """
     # df = pd.DataFrame(columns=["file_name", "label", "accuracy"])
     df_exif = get_exif(get_file_names(files_))
-    print(df_exif)
     return df_exif
 
 
@@ -135,14 +214,22 @@ def update_dataframe(df):
     return df  # Simply return the modified dataframe
 
 
-def df_to_csv(df_):
+def df_to_csv(df_, encodings=None):
     """
     Get the df and convert it as an gradio file output ready for download
     Input: DF created
     Output: gr.File()
     """
-    df_.to_csv("output.csv", index=False, escapechar="\\", quoting=csv.QUOTE_MINIMAL)
-    return gr.File(value="output.csv", visible=True)
+    if encodings is None:
+        encodings = ["utf-8", "utf-8-sig", "latin1", "iso-8859-1", "cp1252"]
+
+    for encoding in encodings:
+        try:
+            df_.to_csv("output.csv", encoding=encoding, index=False)
+            # print(f"File saved successfully with encoding: {encoding}")
+            return gr.File(value="output.csv", visible=True)
+        except Exception as e:
+            print(f"Failed with encoding {encoding}: {e}")
 
 
 ##################################################
@@ -179,15 +266,14 @@ with gr.Blocks() as interface:
     df = gr.DataFrame(interactive=False)
     download_raw_btn.click(
         fn=df_to_csv,
-        inputs=df,
+        inputs=[df],
         outputs=gr.File(visible=False),
-        show_progress=False,
     )
     gr.Markdown("## Modified results")
     df_modified = gr.DataFrame(interactive=True)
     download_modified_btn.click(
         fn=df_to_csv,
-        inputs=df_modified,
+        inputs=[df_modified],
         outputs=gr.File(visible=False),
         show_progress=False,
     )
@@ -198,6 +284,4 @@ with gr.Blocks() as interface:
 
 
 if __name__ == "__main__":
-    # file_path = "../data/rat1.jpg"
-    # get_exif(file_path)
     interface.launch(debug=True)