From c77b37063fa72d99bf0d2d42a1c3300e440c8bbf Mon Sep 17 00:00:00 2001
From: CodeByMrFinchum <mr.finchum@pm.me>
Date: Mon, 30 Dec 2024 23:34:40 +0100
Subject: [PATCH] Legacy deleted
---
main_tui.py | 292 ----------------------------------------------------
1 file changed, 292 deletions(-)
delete mode 100644 main_tui.py
diff --git a/main_tui.py b/main_tui.py
deleted file mode 100644
index 07c7537..0000000
--- a/main_tui.py
+++ /dev/null
@@ -1,292 +0,0 @@
-import os
-import re
-from datetime import datetime
-from utils.utility import Utilities
-from utils.image_handler import ImageProcessor, ExifHandler
-from ui.tui import SimpleTUI
-# legacy code, will be removed with then next minor version
-class Optima35:
- # The layout of class Optima35 was originally made by ChatGPT, but major adjustments have been made. To remain transparent, I disclose this.
- def __init__(self, settings_file, exif_options_file):
- self.name = "OPTIMA-35"
- self.version = "0.2.1"
- self.utilities = Utilities()
- self.image_processor = ImageProcessor()
- self.exif_handler = ExifHandler()
- self.tui = SimpleTUI()
- self.settings = {
- "input_folder": None,
- "output_folder": None,
- "file_format": None,
- "resize_percentage": None,
- "copy_exif": None,
- "contrast_percentage": None,
- "brightness_percentage": None,
- "new_file_names": None,
- "invert_image_order": False,
- "watermark_text": None,
- "modifications": [],
- }
- self.settings_to_save = [
- "resize_percentage",
- "jpg_quality",
- "png_compression",
- "web_optimize",
- "contrast_percentage",
- "brightness_percentage"
- ]
- self.exif_choices = self.utilities.read_yaml(exif_options_file)
- self.setting_file = settings_file
-
- def load_or_ask_settings(self):
- """Load settings from a YAML file or ask the user if not present or incomplete."""
- # Partially ChatGPT
- if self.read_settings(self.settings_to_save):
- for item in self.settings_to_save:
- print(f"{item}: {self.settings[item]}")
- use_saved = self.tui.yes_no_menu("Use these settings?")
- if use_saved:
- return
- else:
- print("No settings found...")
-
- print("Asking for new settings...\n")
- self.settings["resize_percentage"] = self.take_input_and_validate(question = "Default resize percentage (below 100 downscale, above upscale): ", accepted_type = int, min_value = 1, max_value = 200)
- self.settings["contrast_percentage"] = self.take_input_and_validate(question = "Default contrast percentage (negative = decrease, positive = increase): ", accepted_type = int, min_value = -100, max_value = 100)
- self.settings["brightness_percentage"] = self.take_input_and_validate(question = "Default brighness percentage (negative = decrease, positive = increase): ", accepted_type = int, min_value = -100, max_value = 100)
- self.settings["jpg_quality"] = self.take_input_and_validate(question = "JPEG quality (1-100, 80 default): ", accepted_type = int, min_value = 1, max_value = 100)
- self.settings["png_compression"] = self.take_input_and_validate(question = "PNG compression level (0-9, 6 default): ", accepted_type = int, min_value = 0, max_value = 9)
- self.settings["web_optimize"] = self.tui.yes_no_menu("Optimize images i.e. compressing?")
-
- self.write_settings(self.settings_to_save)
-
- def write_settings(self, keys_to_save):
- """"Write self.setting, but only specific values"""
- keys = keys_to_save
- filtered_settings = {key: self.settings[key] for key in keys if key in self.settings}
- self.utilities.write_yaml(self.setting_file, filtered_settings)
- print("New settings saved successfully.")
-
- def read_settings(self, keys_to_load):
- """
- Read settings from the settings file and update self.settings
- with the values for specific keys without overwriting existing values.
- """
- # First draft by ChatGPT, adjusted to fit my needs.
- keys = keys_to_load
- if os.path.exists(self.setting_file):
- loaded_settings = self.utilities.read_yaml(self.setting_file)
- for key in keys:
- if key in loaded_settings:
- self.settings[key] = loaded_settings[key]
- print("Settings loaded successfully.")
- return True
- else:
- print("Settings file empty.")
- return False
-
- def collect_exif_data(self):
- """Collect EXIF data based on user input."""
- user_data = {}
- fields = [
- "make", "model", "lens", "iso", "image_description",
- "user_comment", "artist", "copyright_info"
- ]
- for field in fields:
- choise = self.tui.choose_menu(f"Enter {field.replace('_', ' ').title()}", self.exif_choices[field])
- user_data[field] = choise.encode("utf-8")
-
- user_data["software"] = f"OPTIMA-35 {self.version}".encode("utf-8")
- new_date = self.get_date_input()
-
- if new_date:
- user_data["date_time_original"] = new_date
-
- return user_data
-
- def get_date_input(self):
- # Partially chatGPT
- while True:
- date_input = input("Enter a date (yyyy-mm-dd): ")
- if date_input == "":
- return None # Skip if input is empty
- try:
- new_date = datetime.strptime(date_input, "%Y-%m-%d")
- return new_date.strftime("%Y:%m:%d 00:00:00")
- except ValueError:
- print("Invalid date format. Please enter the date in yyyy-mm-dd format.")
-
- def get_user_settings(self):
- """Get initial settings from the user."""
- menu_options = [
- "Resize image",
- "Change EXIF",
- "Convert to grayscale",
- "Change contrast",
- "Change brightness",
- "Rename images",
- "Invert image order",
- "Add Watermark"
- ] # new option can be added here.
-
- self.settings["input_folder"] = input("Enter path of input folder: ").strip() # Add: check if folder exists.
- self.settings["output_folder"] = input("Enter path of output folder: ").strip()
- self.settings["file_format"] = self.take_input_and_validate(question = "Enter export file format (jpg, png, webp): ", accepted_input = ["jpg", "png", "webp"], accepted_type = str)
- self.settings["modifications"] = self.tui.multi_select_menu(
- f"\n{self.name} v.{self.version} \nSelect what you want to do (esc or q to exit)",
- menu_options
- )
- if "Change EXIF" not in self.settings["modifications"]:
- self.settings["copy_exif"] = self.tui.yes_no_menu("Do you want to copy exif info from original file?")
- if "Rename images" in self.settings["modifications"]:
- self.settings["new_file_names"] = input("What should be the name for the new images? ") # Need
- if "Invert image order" in self.settings["modifications"]:
- self.settings["invert_image_order"] = True
- if "Add Watermark" in self.settings["modifications"]:
- self.settings["watermark_text"] = input("Enter text for watermark. ")
- os.makedirs(self.settings["output_folder"], exist_ok = True)
-
- def take_input_and_validate(self, question, accepted_input = None, accepted_type = str, min_value = None, max_value = None):
- """
- Asks the user a question, validates the input, and ensures it matches the specified criteria.
- Args:
- question (str): The question to ask the user.
- accepted_input (list): A list of acceptable inputs (optional for non-numeric types).
- accepted_type (type): The expected type of input (e.g., str, int, float).
- min_value (int/float): Minimum value for numeric inputs (optional).
- max_value (int/float): Maximum value for numeric inputs (optional).
-
- Returns:
- The validated user input.
- """
- # Main layout by chatGPT, but modified.
- while True:
- user_input = input(question).strip()
-
- try:
- # Convert input to the desired type
- if accepted_type in [int, float]:
- user_input = accepted_type(user_input)
- # Validate range for numeric types
- if (min_value is not None and user_input < min_value) or (max_value is not None and user_input > max_value):
- print(f"Input must be between {min_value} and {max_value}.")
- continue
- elif accepted_type == str:
- # No conversion needed for strings
- user_input = str(user_input)
- else:
- raise ValueError(f"Unsupported type: {accepted_type}")
-
- # Validate against accepted inputs if provided
- if accepted_input is not None and user_input not in accepted_input:
- print(f"Invalid input. Must be one of: {', '.join(map(str, accepted_input))}.")
- continue
-
- return user_input # Input is valid
-
- except ValueError:
- print(f"Invalid input. Must be of type {accepted_type.__name__}.")
-
- def process_images(self):
- """Process images based on user settings."""
- input_folder = self.settings["input_folder"]
- output_folder = self.settings["output_folder"]
-
- image_files = [
- f for f in os.listdir(input_folder) if f.lower().endswith((".png", ".jpg", ".jpeg", ".webp"))
- ]
- if "Change EXIF" in self.settings["modifications"]:
- selected_exif = self.collect_exif_data()
- i = 1
- for image_file in image_files:
- input_path = os.path.join(input_folder, image_file)
-
- if "Rename images" in self.settings["modifications"]:
- image_name = self.name_images(self.settings["new_file_names"], i, len(image_files), self.settings["invert_image_order"])
- else:
- image_name = os.path.splitext(image_file)[0]
-
- output_path = os.path.join(output_folder, image_name)
-
- with self.image_processor.open_image(input_path) as img:
- processed_img = img
- for mod in self.settings["modifications"]:
- if mod == "Resize image":
- processed_img = self.image_processor.resize_image(
- image = processed_img, percent = self.settings["resize_percentage"], resample = True
- )
- elif mod == "Change EXIF" and selected_exif:
- if "date_time_original" in selected_exif:
- selected_exif = self.modify_timestamp_in_exif(selected_exif, image_name)
- exif_data = self.exif_handler.build_exif_dict(selected_exif, self.image_processor.get_image_size(processed_img))
- elif mod == "Convert to grayscale":
- processed_img = self.image_processor.grayscale(processed_img)
- elif mod == "Change contrast":
- processed_img = self.image_processor.change_contrast(processed_img, self.settings["contrast_percentage"])
- elif mod == "Change brightness":
- processed_img = self.image_processor.change_brightness(processed_img, self.settings["brightness_percentage"])
- elif mod == "Add Watermark":
- processed_img = self.image_processor.add_watermark(processed_img, self.settings["watermark_text"])
-
- if self.settings["copy_exif"]:
- # When copying exif from original, make sure to change Piexel X & Y Dimension to fit new size
- try:
- og_exif = self.exif_handler.get_exif_info(img)
- og_exif["Exif"][40962], og_exif["Exif"][40963] = self.image_processor.get_image_size(processed_img)
- exif_data = og_exif
- except Exception:
- # If an error happends it is because the picture does not have exif data
- print("Copying EXIF data selected, but no EXIF data is available in the original image file.")
- exif_data = None
- elif "Change EXIF" not in self.settings["modifications"]:
- exif_data = None
-
- self.image_processor.save_image(
- image = processed_img,
- path = output_path,
- exif_data = exif_data,
- file_type = self.settings["file_format"],
- jpg_quality = self.settings["jpg_quality"],
- png_compressing = self.settings["png_compression"],
- optimize = self.settings["web_optimize"]
- )
- self.utilities.progress_bar(i, len(image_files))
- i += 1
-
- def name_images(self, base_name, current_image, total_images, invert):
- """"Returns name, combination of base_name and ending number."""
- total_digits = len(str(total_images))
- if invert:
- ending_number = total_images - (current_image - 1)
- else:
- ending_number = current_image
- ending = f"{ending_number:0{total_digits}}"
- return f"{base_name}_{ending}"
-
- def modify_timestamp_in_exif(self, exif_data, filename):
- """"Takes exif data and adjust time to fit ending of filename."""
- try:
- last_tree = filename[-3:len(filename)]
- total_seconds = int(re.sub(r'\D+', '', last_tree))
-
- minutes = total_seconds // 60
- seconds = total_seconds % 60
- time = datetime.strptime(exif_data["date_time_original"], "%Y:%m:%d %H:%M:%S") # change date time string back to an time object for modification
- new_time = time.replace(hour=12, minute=minutes, second=seconds)
- exif_data["date_time_original"] = new_time.strftime("%Y:%m:%d %H:%M:%S")
- return exif_data
-
- except ValueError:
- print("Modifying date went wrong, exiting...")
- exit()
-
- def run(self):
- """Run the main program."""
- self.load_or_ask_settings()
- self.get_user_settings()
- self.process_images()
- print("Done")
-
-if __name__ == "__main__":
- app = Optima35("config/settings.yaml", "config/exif_options.yaml")
- app.run()