Upload 13 files

a.py

@@ -0,0 +1,63 @@
+import streamlit as st
+import os
+from PIL import Image
+from collections import Counter
+
+# Function to list files with given extensions
+def list_files(folder_path, extensions):
+    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+    return [f for f in files if f.split('.')[-1] in extensions]
+
+# Function to get tag frequencies from text files
+def get_tag_frequencies(text_files):
+    tag_counter = Counter()
+    for text_file in text_files:
+        with open(text_file, 'r') as file:
+            tags = file.read().split()
+            tag_counter.update(tags)
+    return tag_counter
+
+# Set up Streamlit app
+st.title("Display Images and Corresponding Text Files")
+
+# Define the folder path
+folder_path = "/home/caimera-prod/kohya_new_dataset"
+
+# List of allowed image and text extensions
+image_extensions = ['jpg', 'jpeg', 'png']
+text_extensions = ['txt']
+
+# Get the list of image and text files
+files = list_files(folder_path, image_extensions + text_extensions)
+
+# Filter files into images and texts
+images = [f for f in files if f.split('.')[-1] in image_extensions]
+texts = [f for f in files if f.split('.')[-1] in text_extensions]
+
+# Create a dictionary to map image files to their corresponding text files
+file_map = {}
+for image in images:
+    base_name = os.path.splitext(image)[0]
+    corresponding_text = base_name + '.txt'
+    if corresponding_text in texts:
+        file_map[image] = corresponding_text
+
+# Get tag frequencies
+text_files_paths = [os.path.join(folder_path, text) for text in texts]
+tag_frequencies = get_tag_frequencies(text_files_paths)
+
+# Display tag frequencies
+st.subheader("Tag Frequencies")
+for tag, freq in tag_frequencies.most_common():
+    st.write(f"{tag}: {freq}")
+
+# Display images and text files side by side
+for image_file, text_file in file_map.items():
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.image(os.path.join(folder_path, image_file), caption=image_file, use_column_width=True)
+
+    with col2:
+        with open(os.path.join(folder_path, text_file), 'r') as file:
+            st.text_area(text_file, file.read(), height=300)

b.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import os
+from PIL import Image
+from collections import Counter
+import pandas as pd
+# Function to list files with given extensions
+def list_files(folder_path, extensions):
+    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+    return [f for f in files if f.split('.')[-1] in extensions]
+
+# Function to get tag frequencies from text files
+def get_tag_frequencies(text_files):
+    tag_counter = Counter()
+    for text_file in text_files:
+        with open(text_file, 'r') as file:
+            tags = file.read().split()
+            tag_counter.update(tags)
+    return tag_counter
+
+# Set up Streamlit app
+st.title("Display Images and Corresponding Text Files")
+
+# Define the folder path
+folder_path = "/home/caimera-prod/kohya_new_dataset"
+
+# List of allowed image and text extensions
+image_extensions = ['jpg', 'jpeg', 'png']
+text_extensions = ['txt']
+
+# Get the list of image and text files
+files = list_files(folder_path, image_extensions + text_extensions)
+
+# Filter files into images and texts
+images = [f for f in files if f.split('.')[-1] in image_extensions]
+texts = [f for f in files if f.split('.')[-1] in text_extensions]
+
+# Create a dictionary to map image files to their corresponding text files
+file_map = {}
+for image in images:
+    base_name = os.path.splitext(image)[0]
+    corresponding_text = base_name + '.txt'
+    if corresponding_text in texts:
+        file_map[image] = corresponding_text
+
+# Get tag frequencies
+text_files_paths = [os.path.join(folder_path, text) for text in texts]
+tag_frequencies = get_tag_frequencies(text_files_paths)
+
+# Prepare tag frequencies for display
+tag_frequencies_data = [{'Tag': tag, 'Frequency': freq} for tag, freq in tag_frequencies.items()]
+tag_frequencies_df = pd.DataFrame(tag_frequencies_data)
+
+# Display tag frequencies in a table
+st.subheader("Tag Frequencies")
+st.table(tag_frequencies_df)
+
+# Display images and text files side by side
+for image_file, text_file in file_map.items():
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.image(os.path.join(folder_path, image_file), caption=image_file, use_column_width=True)
+
+    with col2:
+        with open(os.path.join(folder_path, text_file), 'r') as file:
+            st.text_area(text_file, file.read(), height=300)

clean_tag.py

@@ -0,0 +1,37 @@
+import os
+
+def clean_gym_keywords(text):
+    # Split the text by commas
+    parts = [part.strip() for part in text.split(',')]
+    
+    # Remove duplicate "gym" keywords
+    unique_parts = []
+    seen = False
+    for part in parts:
+        if part.lower() == 'gym':
+            if not seen:
+                unique_parts.append(part)
+                seen = True
+        else:
+            unique_parts.append(part)
+            seen = False
+    
+    # Join the parts back into a single string
+    cleaned_text = ', '.join(unique_parts)
+    return cleaned_text
+
+def process_files(folder_path):
+    for filename in os.listdir(folder_path):
+        if filename.endswith('.txt'):
+            file_path = os.path.join(folder_path, filename)
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+            
+            cleaned_content = clean_gym_keywords(content)
+            
+            with open(file_path, 'w', encoding='utf-8') as file:
+                file.write(cleaned_content)
+
+# Specify the path to the folder containing your text files
+folder_path = '/home/caimera-prod/kohya_new_dataset'
+process_files(folder_path)

gpt_caption.py

@@ -0,0 +1,134 @@
+import os
+import time
+import base64
+import requests
+import os
+
+api_key = "sk-proj-uCiflA45fuchFdjkbNJ7T3BlbkFJF5WiEf2zHkttr7s9kijX"
+prompt = """As an AI image tagging expert, please provide precise tags for
+these images to enhance CLIP model's understanding of the content.
+Employ succinct keywords or phrases, steering clear of elaborate
+sentences and extraneous conjunctions. Prioritize the tags by relevance.
+Your tags should capture key elements such as the main subject, setting,
+artistic style, composition, image quality, color tone, filter, and camera
+specifications, and any other tags crucial for the image. When tagging
+photos of people, include specific details like gender, nationality,
+attire, actions, pose, expressions, accessories, makeup, composition
+type, age, etc. For other image categories, apply appropriate and
+common descriptive tags as well. Recognize and tag any celebrities,
+ well-known landmark or IPs if clearly featured in the image.
+ Your tags should be accurate, non-duplicative, and within a
+ 20-75 word count range. These tags will use for image re-creation,
+ so the closer the resemblance to the original image, the better the
+ tag quality. Tags should be comma-separated. Exceptional tagging will
+ be rewarded with $10 per image.
+"""
+rule_prompt = """
+Follow this rules while captioning if the images have models:\n
+1. For gender identification utilze Male or Female, e.g : young female \n
+2. You can add the ethinicity to the gender tag, e.g : young Indian female, african male \n
+3. Specify the body composition or model composition always. If the body composition have any
+discripencies be more specific.\n
+4. If the image have a specific activity state the particular activity e.g: yoga, swimming, gym
+5. Do not add objects which are not present in the Image.\n
+"""
+def encode_image(image_path):
+  with open(image_path, "rb") as image_file:
+    return base64.b64encode(image_file.read()).decode('utf-8')
+
+def create_openai_query(image_path):
+  base64_image = encode_image(image_path)
+  headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}"
+  }
+  payload = {
+    "model": "gpt-4o",
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": (prompt+rule_prompt)
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": f"data:image/jpeg;base64,{base64_image}"
+            }
+          }
+        ]
+      }
+    ],
+    "max_tokens": 300
+  }
+
+  response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
+  output = response.json()
+  print(output)
+  return output['choices'][0]['message']['content']
+
+
+def process_images_in_folder(input_folder, output_folder, resume_from=None):
+    os.makedirs(output_folder, exist_ok=True)
+
+    image_files = [
+        f for f in os.listdir(input_folder)
+        if os.path.isfile(os.path.join(input_folder, f)) and not (f.endswith('.txt') or f.endswith('.npz'))]
+
+    # Track processed images
+    processed_log = os.path.join(output_folder, "processed_log.txt")
+    processed_images = set()
+
+    # Read processed log if it exists
+    if os.path.exists(processed_log):
+        with open(processed_log, 'r') as log_file:
+            processed_images = {line.strip() for line in log_file.readlines()}
+
+    try:
+        for image_file in image_files:
+            if resume_from and image_file <= resume_from:
+                continue  # Skip images already processed
+
+            image_path = os.path.join(input_folder, image_file)
+
+            # Check if already processed
+            if image_file in processed_images:
+                print(f"Skipping {image_file} as it is already processed.")
+                continue
+
+            try:
+                # Simulating the processing function (replace with actual call)
+                processed_output = create_openai_query(image_path)
+            except Exception as e:
+                print(f"Error processing {image_file}: {str(e)}")
+                processed_output = ""  # Stop processing further on error
+
+            # Save processed output to a text file
+            output_text_file_path = os.path.join(output_folder, f"{os.path.splitext(image_file)[0]}.txt")
+            with open(output_text_file_path, 'w') as f:
+                f.write(processed_output)
+
+            # Copy the image to the output folder
+            # output_image_path = os.path.join(output_folder, image_file)
+            # shutil.copy(image_path, output_image_path)
+
+            # Log processed image
+            with open(processed_log, 'a') as log_file:
+                log_file.write(f"{image_file}\n")
+
+            print(f"Processed {image_file} and saved result to {output_text_file_path}")
+
+    except Exception as e:
+        print(f"Error occurred: {str(e)}. Resuming might not be possible.")
+        return
+
+if __name__ == "__main__":
+    input_folder = "/home/caimera-prod/Paid-data"
+    output_folder = "/home/caimera-prod/Paid-data"
+
+    # Replace with the last successfully processed image filename (without extension) to resume from that point
+    resume_from = None  # Example: "image_003"
+
+    process_images_in_folder(input_folder, output_folder, resume_from)

gpt_eye_tagger.py

@@ -0,0 +1,117 @@
+import os
+import time
+import base64
+import requests
+import os
+
+api_key = "sk-proj-uCiflA45fuchFdjkbNJ7T3BlbkFJF5WiEf2zHkttr7s9kijX"
+prompt = """As an AI image tagging expert, please provide one precise tag of the eye for
+these images to enhance CLIP model's understanding of the content.
+Employ succinct keywords or phrases, steering clear of elaborate
+sentences and extraneous conjunctions.
+"""
+rule_prompt = """
+Follow this rules while captioning the eye:
+If eye is not visible then tag the pose
+If eye is visible tag it in details along with ethnicity for example round nepali woman eye
+"""
+def encode_image(image_path):
+  with open(image_path, "rb") as image_file:
+    return base64.b64encode(image_file.read()).decode('utf-8')
+
+def create_openai_query(image_path):
+  base64_image = encode_image(image_path)
+  headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {api_key}"
+  }
+  payload = {
+    "model": "gpt-4o",
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": (prompt+rule_prompt)
+          },
+          {
+            "type": "image_url",
+            "image_url": {
+              "url": f"data:image/jpeg;base64,{base64_image}"
+            }
+          }
+        ]
+      }
+    ],
+    "max_tokens": 300
+  }
+
+  response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
+  output = response.json()
+  print(output)
+  return output['choices'][0]['message']['content']
+
+
+def process_images_in_folder(input_folder, output_folder, resume_from=None):
+    os.makedirs(output_folder, exist_ok=True)
+
+    image_files = [
+        f for f in os.listdir(input_folder)
+        if os.path.isfile(os.path.join(input_folder, f)) and not (f.endswith('.txt') or f.endswith('.npz'))]
+
+    # Track processed images
+    processed_log = os.path.join(output_folder, "processed_log.txt")
+    processed_images = set()
+
+    # Read processed log if it exists
+    if os.path.exists(processed_log):
+        with open(processed_log, 'r') as log_file:
+            processed_images = {line.strip() for line in log_file.readlines()}
+
+    try:
+        for image_file in image_files:
+            if resume_from and image_file <= resume_from:
+                continue  # Skip images already processed
+
+            image_path = os.path.join(input_folder, image_file)
+
+            # Check if already processed
+            if image_file in processed_images:
+                print(f"Skipping {image_file} as it is already processed.")
+                continue
+
+            try:
+                # Simulating the processing function (replace with actual call)
+                processed_output = create_openai_query(image_path)
+            except Exception as e:
+                print(f"Error processing {image_file}: {str(e)}")
+                processed_output = ""  # Stop processing further on error
+
+            # Save processed output to a text file
+            output_text_file_path = os.path.join(output_folder, f"{os.path.splitext(image_file)[0]}.txt")
+            with open(output_text_file_path, 'w') as f:
+                f.write(processed_output)
+
+            # Copy the image to the output folder
+            # output_image_path = os.path.join(output_folder, image_file)
+            # shutil.copy(image_path, output_image_path)
+
+            # Log processed image
+            with open(processed_log, 'a') as log_file:
+                log_file.write(f"{image_file}\n")
+
+            print(f"Processed {image_file} and saved result to {output_text_file_path}")
+
+    except Exception as e:
+        print(f"Error occurred: {str(e)}. Resuming might not be possible.")
+        return
+
+if __name__ == "__main__":
+    input_folder =  "/home/caimera-prod/eye_tagged_data"
+    output_folder = "/home/caimera-prod/eye_tagged_data"
+
+    # Replace with the last successfully processed image filename (without extension) to resume from that point
+    resume_from = None  # Example: "image_003"
+
+    process_images_in_folder(input_folder, output_folder, resume_from)

python_script.py

@@ -0,0 +1,17 @@
+import cv2
+import numpy as np
+import os
+
+image_folder = "masked_loss_training_data/images"
+mask_folder = "masked_loss_training_data/conditioning"
+
+image_files = os.listdir(image_folder)
+jpg_files = [f for f in image_files if f.endswith('.jpg')]
+
+for file_name in jpg_files:
+  img = cv2.imread(os.path.join(image_folder, file_name), cv2.IMREAD_GRAYSCALE)
+  _, bw_mask = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
+  output_file_path = os.path.join(mask_folder, os.path.splitext(file_name)[0] + '.png')
+  cv2.imwrite(output_file_path, bw_mask)
+
+

st.py

@@ -0,0 +1,45 @@
+import streamlit as st
+import os
+from PIL import Image
+
+# Function to list files with given extensions
+def list_files(folder_path, extensions):
+    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+    return [f for f in files if f.split('.')[-1] in extensions]
+
+# Set up Streamlit app
+st.title("Display Images and Corresponding Text Files")
+
+# Define the folder path
+folder_path = "/home/caimera-prod/kohya_new_dataset"
+
+# List of allowed image and text extensions
+image_extensions = ['jpg', 'jpeg', 'png']
+text_extensions = ['txt']
+
+# Get the list of image and text files
+files = list_files(folder_path, image_extensions + text_extensions)
+
+# Filter files into images and texts
+images = [f for f in files if f.split('.')[-1] in image_extensions]
+texts = [f for f in files if f.split('.')[-1] in text_extensions]
+
+# Create a dictionary to map image files to their corresponding text files
+file_map = {}
+for image in images:
+    base_name = os.path.splitext(image)[0]
+    corresponding_text = base_name + '.txt'
+    if corresponding_text in texts:
+        file_map[image] = corresponding_text
+
+# Display images and text files side by side
+for image_file, text_file in file_map.items():
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.image(os.path.join(folder_path, image_file), caption=image_file, use_column_width=True)
+    
+    with col2:
+        with open(os.path.join(folder_path, text_file), 'r') as file:
+            st.text_area(text_file, file.read(), height=300)
+

st_eye_plot.py

@@ -0,0 +1,61 @@
+import os
+from collections import Counter
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from PIL import Image
+
+# Streamlit app title
+st.title('Interactive Tag Frequency Visualization')
+
+# Folder path
+folder_path = "/home/caimera-prod/eye_tagged_data"
+
+if folder_path:
+    # Initialize a Counter to count tag frequency
+    tag_counter = Counter()
+    file_resolutions = []
+
+    # Iterate through each .txt file in the folder
+    for file_name in os.listdir(folder_path):
+        if file_name.endswith('.txt'):
+            file_path = os.path.join(folder_path, file_name)
+            with open(file_path, 'r') as file:
+                content = file.read().strip()
+                if 'eye' in content.lower():  # Check if 'eye' is in the content
+                    tags = content.split(',')
+                    # Clean and count each tag
+                    tags = [tag.strip().lower() for tag in tags]
+                    tag_counter.update(tags)
+
+                    # Find the corresponding image and get its resolution
+                    image_name = file_name.replace('.txt', '.jpg')  # Assuming the images are in .jpg format
+                    image_path = os.path.join(folder_path, image_name)
+                    if os.path.exists(image_path):
+                        image = Image.open(image_path)
+                        resolution = image.size  # (width, height)
+                        file_resolutions.append((file_name, resolution[0], resolution[1]))
+                    else:
+                        file_resolutions.append((file_name, 'N/A', 'N/A'))  # In case the image is not found
+
+    # Convert the Counter and resolution data to a DataFrame for better display
+    tag_data = pd.DataFrame(tag_counter.items(), columns=['Tag', 'Count'])
+    tag_data = tag_data.sort_values(by='Count', ascending=False).reset_index(drop=True)
+
+    resolution_data = pd.DataFrame(file_resolutions, columns=['File Name', 'Width', 'Height'])
+
+    # Display the DataFrame as a table in Streamlit
+    if not tag_data.empty:
+        st.subheader('Tag Frequency Table')
+        st.dataframe(tag_data)
+
+        st.subheader('Image Resolutions for Files Containing "eye"')
+        st.dataframe(resolution_data)
+
+        # Create an interactive bar chart using Plotly
+        st.subheader('Interactive Tag Frequency Bar Chart')
+        fig = px.bar(tag_data, x='Tag', y='Count', title='Tag Frequency', labels={'Count': 'Frequency'}, height=600)
+        fig.update_layout(xaxis_title='Tags', yaxis_title='Frequency')
+        st.plotly_chart(fig)
+    else:
+        st.write("No tags found in files containing the word 'eye'.")

st_tag_clean.py

@@ -0,0 +1,44 @@
+import os
+from collections import Counter
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+
+# Streamlit app title
+# st.title('Interactive Tag Frequency Visualization')
+
+# File uploader to select folder
+folder_path = "/home/caimera-prod/kohya_new_dataset"
+
+if folder_path:
+    # Initialize a Counter to count tag frequency
+    tag_counter = Counter()
+
+    # Iterate through each .txt file in the folder
+    for file_name in os.listdir(folder_path):
+        if file_name.endswith('.txt'):
+            file_path = os.path.join(folder_path, file_name)
+            with open(file_path, 'r') as file:
+                tags = file.read().strip().split(',')
+                # Clean, filter out empty tags, and count each tag
+                tags = [tag.strip().lower() for tag in tags if tag.strip()]
+                tag_counter.update(tags)
+
+    # Convert the Counter to a DataFrame for better display
+    tag_data = pd.DataFrame(tag_counter.items(), columns=['Tag', 'Count'])
+    
+    # Filter out any rows with empty tags in the DataFrame (shouldn't be necessary after above filtering)
+    tag_data = tag_data[tag_data['Tag'] != '']
+    
+    # Sort the DataFrame by count
+    tag_data = tag_data.sort_values(by='Count', ascending=False).reset_index(drop=True)
+
+    # Display the DataFrame as a table in Streamlit
+    st.subheader('Tag Frequency Table')
+    st.dataframe(tag_data)
+
+    # Create an interactive bar chart using Plotly
+    st.subheader('Interactive Tag Frequency Bar Chart')
+    fig = px.bar(tag_data, x='Tag', y='Count', title='Tag Frequency', labels={'Count': 'Frequency'}, height=600)
+    fig.update_layout(xaxis_title='Tags', yaxis_title='Frequency')
+    st.plotly_chart(fig)

stream_lit_plotly.py

@@ -0,0 +1,39 @@
+import os
+from collections import Counter
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+
+# Streamlit app title
+# st.title('Interactive Tag Frequency Visualization')
+
+# File uploader to select folder
+folder_path = "/home/caimera-prod/eye_tagged_data"
+
+if folder_path:
+    # Initialize a Counter to count tag frequency
+    tag_counter = Counter()
+
+    # Iterate through each .txt file in the folder
+    for file_name in os.listdir(folder_path):
+        if file_name.endswith('.txt'):
+            file_path = os.path.join(folder_path, file_name)
+            with open(file_path, 'r') as file:
+                tags = file.read().strip().split(',')
+                # Clean and count each tag
+                tags = [tag.strip().lower() for tag in tags]
+                tag_counter.update(tags)
+
+    # Convert the Counter to a DataFrame for better display
+    tag_data = pd.DataFrame(tag_counter.items(), columns=['Tag', 'Count'])
+    tag_data = tag_data.sort_values(by='Count', ascending=False).reset_index(drop=True)
+
+    # Display the DataFrame as a table in Streamlit
+    st.subheader('Tag Frequency Table')
+    st.dataframe(tag_data)
+
+    # Create an interactive bar chart using Plotly
+    st.subheader('Interactive Tag Frequency Bar Chart')
+    fig = px.bar(tag_data, x='Tag', y='Count', title='Tag Frequency', labels={'Count': 'Frequency'}, height=600)
+    fig.update_layout(xaxis_title='Tags', yaxis_title='Frequency')
+    st.plotly_chart(fig)

stream_new.py

@@ -0,0 +1,65 @@
+import streamlit as st
+import os
+from PIL import Image
+import math
+
+# Function to list files with given extensions
+def list_files(folder_path, extensions):
+    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+    return [f for f in files if f.split('.')[-1] in extensions]
+
+# Set up Streamlit app
+st.title("Display Images and Corresponding Text Files")
+
+# Define the folder path
+folder_path = "/home/caimera-prod/kohya_new_dataset"
+
+# List of allowed image and text extensions
+image_extensions = ['jpg', 'jpeg', 'png']
+text_extensions = ['txt']
+
+# Get the list of image and text files
+files = list_files(folder_path, image_extensions + text_extensions)
+
+# Filter files into images and texts
+images = [f for f in files if f.split('.')[-1] in image_extensions]
+texts = [f for f in files if f.split('.')[-1] in text_extensions]
+
+# Create a dictionary to map image files to their corresponding text files
+file_map = {}
+for image in images:
+    base_name = os.path.splitext(image)[0]
+    corresponding_text = base_name + '.txt'
+    if corresponding_text in texts:
+        file_map[image] = corresponding_text
+
+# Pagination settings
+items_per_page = 5
+total_items = len(file_map)
+total_pages = math.ceil(total_items / items_per_page)
+page = st.sidebar.slider('Page', 1, total_pages, 1)
+
+# Calculate the start and end indices for the current page
+start_idx = (page - 1) * items_per_page
+end_idx = start_idx + items_per_page
+
+# Display images and text files side by side with editing capability
+for image_file, text_file in list(file_map.items())[start_idx:end_idx]:
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.image(os.path.join(folder_path, image_file), caption=image_file, use_column_width=True)
+
+    with col2:
+        text_path = os.path.join(folder_path, text_file)
+        with open(text_path, 'r') as file:
+            text_content = file.read()
+
+        # Text area for editing text content
+        updated_text = st.text_area(text_file, text_content, height=300)
+
+        # Save the edited content back to the file if changes were made
+        if st.button(f'Save {text_file}'):
+            with open(text_path, 'w') as file:
+                file.write(updated_text)
+            st.success(f"Changes to {text_file} saved successfully.")

streamlit.py

@@ -0,0 +1,33 @@
+import os
+from collections import Counter
+import streamlit as st
+import pandas as pd
+
+# Streamlit app title
+# st.title('Tag Frequency Table')
+
+# File uploader to select folder
+folder_path = "/home/caimera-prod/Paid-data"
+
+if folder_path:
+    # Initialize a Counter to count tag frequency
+    tag_counter = Counter()
+
+    # Iterate through each .txt file in the folder
+    for file_name in os.listdir(folder_path):
+        if file_name.endswith('.txt'):
+            file_path = os.path.join(folder_path, file_name)
+            with open(file_path, 'r') as file:
+                tags = file.read().strip().split(',')
+                # Clean and count each tag
+                tags = [tag.strip().lower() for tag in tags]
+                tag_counter.update(tags)
+
+    # Convert the Counter to a DataFrame for better display
+    tag_data = pd.DataFrame(tag_counter.items(), columns=['Tag', 'Count'])
+    tag_data = tag_data.sort_values(by='Count', ascending=False).reset_index(drop=True)
+
+    # Display the DataFrame as a table in Streamlit
+    st.subheader('Tag Frequency Table')
+    st.table(tag_data)
+

transfer.py

@@ -0,0 +1,28 @@
+import os
+import shutil
+
+def move_non_npz_files(source_folder, destination_folder):
+    # Ensure the destination folder exists
+    if not os.path.exists(destination_folder):
+        os.makedirs(destination_folder)
+
+    # Iterate over all files in the source folder
+    for filename in os.listdir(source_folder):
+        # Construct the full file path
+        source_file_path = os.path.join(source_folder, filename)
+
+        # Check if the current item is a file (not a directory) and not a .npz file
+        if os.path.isfile(source_file_path) and not filename.endswith('.npz'):
+            # Construct the destination file path
+            destination_file_path = os.path.join(destination_folder, filename)
+
+            # Move the file
+            shutil.move(source_file_path, destination_file_path)
+            print(f'Moved: {filename} to {destination_folder}')
+
+# Define your source and destination folders
+source_folder = '/path/to/source/folder'
+destination_folder = '/path/to/destination/folder'
+
+# Move non-.npz files
+move_non_npz_files(source_folder, destination_folder)