planetis-m · September 15, 2024 01:26
diff --git a/fix_fuzzy.py b/fix_fuzzy.py
 import random
 import os
 import string
 import polib
 # import tempfile
 # import subprocess
 from termcolor import colored
 from difflib import SequenceMatcher

 # Letter Frequencies of the Greek language
 GREEK_LETTER_PENALTIES = {
  'α': 10.81, 'τ': 7.99, 'ο': 7.23, 'ε': 7.18, 'σ': 7.00, 'ι': 6.64,
  'ν': 6.19, 'ρ': 4.32, 'π': 4.15, 'κ': 3.77, 'μ': 3.43, 'η': 3.18,
  'υ': 3.04, 'λ': 2.66, 'γ': 1.70, 'δ': 1.63, 'χ': 1.29, 'ω': 1.23,
  'θ': 1.22, 'φ': 0.74, 'β': 0.67, 'ξ': 0.44, 'ζ': 0.33, 'ψ': 0.15
 }

 # List of Greek letters to exclude
 EXCLUDED_LETTERS = {'ά', 'έ', 'ή', 'ί', 'ό', 'ύ', 'ώ', 'ϊ', 'ϋ', 'ΐ', 'ΰ', 'ς'}

 def detect_ampersand_changes(old_msgid, new_msgid):
  """
  Detect if an ampersand (&) has been added or removed between old_msgid and new_msgid.
  Ignore escaped ampersands (&&).
  """
  # Count non-escaped ampersands (&) by removing '&&' and counting remaining '&'
  old_ampersands = old_msgid.count('&') - old_msgid.count('&&') * 2
  new_ampersands = new_msgid.count('&') - new_msgid.count('&&') * 2

  if old_ampersands != new_ampersands:
    return old_ampersands, new_ampersands
  return old_ampersands, new_ampersands

 def remove_unescaped_ampersand(msgstr, count_to_remove):
  """
  Remove only unescaped ampersands (&) from the string, leaving escaped ampersands (&&) intact.
  `count_to_remove` specifies how many ampersands to remove.
  """
  result = []
  i = 0
  ampersands_removed = 0
  while i < len(msgstr):
    # Check for escaped ampersands (&&)
    if msgstr[i:i+2] == '&&':
      result.append('&&')
      i += 2  # Skip both '&'
    elif msgstr[i] == '&' and ampersands_removed < count_to_remove:
      # Remove the unescaped ampersand
      ampersands_removed += 1
      i += 1  # Skip this '&'
    else:
      result.append(msgstr[i])
      i += 1
  return ''.join(result)

 def apply_ampersand_change(old_msgid, new_msgid, msgstr):
  """
  Apply the ampersand change to msgstr. If ampersand was removed, remove it from msgstr.
  If ampersand was added, assign it randomly to a letter in msgstr.
  """
  old_ampersands, new_ampersands = detect_ampersand_changes(old_msgid, new_msgid)

  if new_ampersands > old_ampersands:
    # Ampersand added, assign it randomly
    ampersands_to_add = new_ampersands - old_ampersands
    return (True, assign_ampersand_randomly(msgstr, ampersands_to_add))
  elif old_ampersands > new_ampersands:
    # Ampersand removed, remove from msgstr
    return (True, remove_unescaped_ampersand(msgstr, old_ampersands - new_ampersands))
  elif new_ampersands > 0:
    # Ampersand's location moved.
    return (True, msgstr)
  return (False, msgstr)

 def assign_ampersand_randomly(msgstr, ampersands_to_add):
  """
  Assign ampersands randomly to letters in msgstr.
  Penalize common Greek letters and exclude vowels with diacritics.
  """
  # Filter out excluded vowels and create a list of unique letters in the msgstr
  unique_letters = [ch for ch in set(msgstr.lower()) if ch not in EXCLUDED_LETTERS and ch.isalpha()]

  if not unique_letters:
    # No valid letters to assign ampersands, return unchanged msgstr
    return msgstr

  # Create a list of letters with their penalties
  weighted_letters = []
  for letter in unique_letters:
    penalty = GREEK_LETTER_PENALTIES.get(letter, 1)  # Higher penalty for common letters
    weighted_letters.extend([letter] * int(100 / penalty))  # More penalty = fewer chances

  # Randomly assign ampersands to letters in msgstr
  for _ in range(ampersands_to_add):
    chosen_letter = random.choice(weighted_letters)
    msgstr = insert_ampersand_before_letter(msgstr, chosen_letter)
  return msgstr

 def insert_ampersand_before_letter(msgstr, letter):
  """Insert ampersand (&) before the first occurrence of the chosen letter (lowercase or uppercase) in msgstr."""
  lower_letter = letter.lower()
  upper_letter = letter.upper()

  lower_index = msgstr.find(lower_letter)
  upper_index = msgstr.find(upper_letter)

  if lower_index == -1 and upper_index == -1:
    return msgstr
  elif lower_index == -1 or (upper_index != -1 and upper_index < lower_index):
    return msgstr.replace(upper_letter, f'&{upper_letter}', 1)
  else:
    return msgstr.replace(lower_letter, f'&{lower_letter}', 1)

 def detect_trailing_changes(old, new):
  """
  Detect if certain trailing characters like '...' have been added or removed
  between the old msgid and new msgid.
  """
  # Define the trailing patterns to look for
  trailing_patterns = ['...', '…', ': ', ':', '.', ', ', ',']

  def find_trailing_pattern(s):
    for pattern in trailing_patterns:
      if s.endswith(pattern):
        return pattern
    return None

  old_trailing = find_trailing_pattern(old)
  new_trailing = find_trailing_pattern(new)

  if old_trailing != new_trailing:
    return old_trailing, new_trailing
  return None, None

 def apply_trailing_change(old_msgid, new_msgid, msgstr):
  """
  Automatically apply trailing changes if the trailing pattern has been modified
  between old_msgid and new_msgid.
  """
  old_trailing, new_trailing = detect_trailing_changes(old_msgid, new_msgid)
  if old_trailing is None and new_trailing is None:
    # No trailing changes detected
    return (False, msgstr)
  # Remove old trailing pattern from msgstr if it exists
  if old_trailing and msgstr.endswith(old_trailing):
    msgstr = msgstr[:-len(old_trailing)].rstrip()
  # Add the new trailing pattern to msgstr if a new one exists
  if new_trailing and not msgstr.endswith(new_trailing):
    msgstr = msgstr.rstrip() + new_trailing
  return (True, msgstr)

 def apply_case_change(old_msgid, new_msgid, msgstr):
  def sentence_case(s):
    return s[0].upper() + s[1:].lower()
  # Check if new_str is the sentence-cased version of old_msgid
  if sentence_case(old_msgid) == new_msgid:
    # Apply the same sentence casing to msg
    return (True, sentence_case(msgstr))
  if new_msgid[0].islower():
    # Apply lowercase to all letters in msgstr
    return (True, msgstr.lower())
  if old_msgid == sentence_case(new_msgid):
    # Words titled cased, ignore.
    return (True, msgstr)
  return (False, msgstr)

 def is_minor_change(old, new):
  """
  Detect if the change is minor based on normalization (case, punctuation, whitespace changes).
  Return True if the change is minor.
  """
  normalized_old = normalize_string(old)
  normalized_new = normalize_string(new)

  return normalized_old == normalized_new

 def normalize_string(s):
  """Normalize a string by lowercasing, removing punctuation, and normalizing whitespace."""
  normalized = []
  prev_char = None
  # punctuation = string.punctuation + "…"
  punctuation = '.&:,…'
  for ch in s:
    if ch in punctuation:
      continue  # Skip punctuation
    if ch.isspace():
      # Only append a single space when encountering multiple spaces
      if prev_char != ' ':
        normalized.append(' ')
      prev_char = ' '
    else:
      normalized.append(ch.lower())
      prev_char = ch.lower()
  return ''.join(normalized).strip()

 # def open_editor_with_content(initial_content):
 #   """Open the user's default editor to edit multiline text."""
 #   # Create a temporary file
 #   with tempfile.NamedTemporaryFile(suffix=".tmp", mode='w+', delete=False) as tmp_file:
 #     # Write initial content (the current msgstr) to the temporary file
 #     tmp_file.write(initial_content)
 #     tmp_file_name = tmp_file.name
 #   # Try to get the user's default editor from environment variables, fallback to 'nano'
 #   editor = os.environ.get('EDITOR', 'nano')
 #   # Open the temporary file in the editor
 #   subprocess.call([editor, tmp_file_name])
 #   # After the user closes the editor, read the file back
 #   with open(tmp_file_name, 'r') as tmp_file:
 #     edited_content = tmp_file.read()
 #   # Clean up the temporary file
 #   os.remove(tmp_file_name)
 #
 #   return edited_content.strip()

 def colored_inline_diff(str1, str2):
  # Create a SequenceMatcher object
  matcher = SequenceMatcher(None, str1, str2)
  # Process the diff
  for op, i1, i2, j1, j2 in matcher.get_opcodes():
    if op == 'equal':
      print(str1[i1:i2], end='')
    elif op == 'delete':
      print(colored(str1[i1:i2], 'white', 'on_red'), end='')
    elif op == 'insert':
      print(colored(str2[j1:j2], 'green'), end='')
    elif op == 'replace':
      print(colored(str1[i1:i2], 'white', 'on_red') + colored(str2[j1:j2], 'green'), end='')
  print()  # Add a newline at the end

 def print_header(text):
  print(colored(f"\n=== {text} ===", "yellow", attrs=["bold"]))

 def print_subheader(text):
  print(colored(f"  {text}", "cyan"))

 def print_info(text):
  print(colored(f"{text}", "magenta", attrs=["bold"]))

 def print_change(text):
  print(colored(f"  {text}", "green"))

 def print_unchanged(text):
  print(colored(f"  {text}", "dark_grey"))

 from enum import Enum

 class MsgstrChangeStatus(Enum):
  SAVED_AS_IS = 1   # When the entry was saved as is, without further changes
  AUTO_APPLIED = 2  # When the change was auto-applied to msgstr
  UNCHANGED = 3     # When no changes were applied

 def process_msgstr_change(current_msgstr, new_msgstr, change_applied):
  """
  Process the changes to msgstr, returning the new msgstr and a status Enum representing the result.
  """
  if new_msgstr != current_msgstr:
    return MsgstrChangeStatus.AUTO_APPLIED  # Change is auto-applied
  elif change_applied:
    return MsgstrChangeStatus.SAVED_AS_IS  # Entry saved as is
  else:
    return MsgstrChangeStatus.UNCHANGED  # No changes applied

 def detect_and_preapply_changes(entry):
  """
  Detect if the msgid or msgid_plural has added or removed trailing characters and apply the same change to msgstr_plural[0] (singular form)
  and msgstr_plural[1] (plural form). If the change is minor (punctuation, case, etc.), pre-apply it automatically.
  """
  old_msgid = entry.previous_msgid
  new_msgid = entry.msgid
  old_msgid_plural = entry.previous_msgid_plural
  new_msgid_plural = entry.msgid_plural

  # Helper function to apply changes to msgstr (both singular and plural)
  def apply_changes_to_strs(old, new, msgstr):
    change_applied = False
    applied, new_msgstr = apply_ampersand_change(old, new, msgstr)
    change_applied = change_applied or applied
    applied, new_msgstr = apply_trailing_change(old, new, new_msgstr)
    change_applied = change_applied or applied
    applied, new_msgstr = apply_case_change(old, new, new_msgstr)
    change_applied = change_applied or applied
    return change_applied, new_msgstr

  is_minor_change_plural = bool(old_msgid_plural and new_msgid_plural) and \
      is_minor_change(old_msgid_plural, new_msgid_plural)
  # Handle singular and plural together if both exist
  if old_msgid and is_minor_change(old_msgid, new_msgid) and \
      bool(entry.msgstr_plural) == is_minor_change_plural: # XNOR
    print_subheader(f"Detected minor change in msgid:")
    colored_inline_diff(old_msgid, new_msgid)
    if is_minor_change_plural:
      colored_inline_diff(old_msgid_plural, new_msgid_plural)

    change_applied = False
    # Apply changes to the singular form
    applied, new_msgstr_singular = apply_changes_to_strs(
      old_msgid, new_msgid,
      entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr
    )
    change_applied = change_applied or applied

    status_singular = process_msgstr_change(
      entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr,
      new_msgstr_singular,
      change_applied or old_msgid == new_msgid
    )
    # If there is a plural form, apply changes to msgstr_plural[1]
    if entry.msgstr_plural and 1 in entry.msgstr_plural:
      applied, new_msgstr_plural = apply_changes_to_strs(old_msgid_plural,
          new_msgid_plural, entry.msgstr_plural[1])
      change_applied = change_applied or applied

      status_plural = process_msgstr_change(
        entry.msgstr_plural[1],
        new_msgstr_plural,
        change_applied or old_msgid_plural == new_msgid_plural
      )
    else:
      status_plural = MsgstrChangeStatus.SAVED_AS_IS

    if status_singular == MsgstrChangeStatus.UNCHANGED or \
        status_plural == MsgstrChangeStatus.UNCHANGED:
      print_unchanged("↳ Entry NOT changed:")
      print(new_msgstr_singular)
      if is_minor_change_plural:
        print(new_msgstr_plural)
      return False  # Change is not minor, user will handle it

    if status_singular == MsgstrChangeStatus.AUTO_APPLIED:
      print_change("↳ Auto-applied change to entry:")
      colored_inline_diff(
        entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr,
        new_msgstr_singular
      )
      if is_minor_change_plural:
        colored_inline_diff(entry.msgstr_plural[1], new_msgstr_plural)
    elif status_singular == MsgstrChangeStatus.SAVED_AS_IS:
      print_change("↳ Entry saved as is:")
      print(new_msgstr_singular)
      if is_minor_change_plural:
        print(new_msgstr_plural)

    if status_singular == MsgstrChangeStatus.AUTO_APPLIED:
      if is_minor_change_plural:
        entry.msgstr_plural[0] = new_msgstr_singular
        entry.msgstr_plural[1] = new_msgstr_plural
      else:
        entry.msgstr = new_msgstr_singular
  else:
    print_unchanged(f"No changes applied due to complexity.")
    return False  # Change is not minor, user will handle it

 def edit_msgstr(entry):
  """Function to edit msgstr with multiline editing support and pre-applied changes."""
  # print(f"\nmsgid: {entry.msgid}")
  # if entry.previous_msgid:
  #   print("\nDiff with previous_msgid:")
  #   colored_inline_diff(entry.previous_msgid, entry.msgid)
  # Detect and pre-apply changes if msgid changed regarding trailing dots/ellipsis/colon/period
  detect_and_preapply_changes(entry)
  # # Show the current msgstr
  # print(f"\nCurrent msgstr: {entry.msgstr}")
  # # Prompt the user for action (edit, save, or skip)
  # while True:
  #   action = input("Choose an action - [e]dit, [s]ave, or [k]skip: ").strip().lower()
  #   if action == 'e':
  #     # Open the user's editor with the current msgstr as the initial content
  #     new_msgstr = open_editor_with_content(entry.msgstr)
  #     # Update the msgstr if it was edited
  #     if new_msgstr != entry.msgstr:
  #       entry.msgstr = new_msgstr
  #       print(f"\nUpdated msgstr: {entry.msgstr}")
  #     break
  #   elif action == 's':
  #     # Just save the current msgstr (possibly pre-applied changes)
  #     break
  #   elif action == 'k':
  #     # Skip saving changes
  #     return False
  # return True

 def process_po_file(filepath):
  """Process the .po file and handle fuzzy entries."""
  po = polib.pofile(filepath)
  changed = False

  for entry in po.fuzzy_entries():
    print_header(f"Editing fuzzy entry in {filepath}:{entry.linenum}")
    if edit_msgstr(entry):
      entry.flags.remove('fuzzy')  # Remove the fuzzy flag
      changed = True

  if changed:
    print_info(f"Saving changes to {filepath}...")
    po.save()

 def scan_directory(directory):
  """Scan the directory for .po files and process them."""
  for root, _, files in os.walk(directory):
    for file in files:
      if file.endswith('.po'):
        filepath = os.path.join(root, file)
        process_po_file(filepath)

 if __name__ == "__main__":
  directory = input("Enter the directory to scan for .po files: ").strip()
  scan_directory(directory)
	import random
	import os
	import string
	import polib
	# import tempfile
	# import subprocess
	from termcolor import colored
	from difflib import SequenceMatcher

	# Letter Frequencies of the Greek language
	GREEK_LETTER_PENALTIES = {
	'α': 10.81, 'τ': 7.99, 'ο': 7.23, 'ε': 7.18, 'σ': 7.00, 'ι': 6.64,
	'ν': 6.19, 'ρ': 4.32, 'π': 4.15, 'κ': 3.77, 'μ': 3.43, 'η': 3.18,
	'υ': 3.04, 'λ': 2.66, 'γ': 1.70, 'δ': 1.63, 'χ': 1.29, 'ω': 1.23,
	'θ': 1.22, 'φ': 0.74, 'β': 0.67, 'ξ': 0.44, 'ζ': 0.33, 'ψ': 0.15
	}

	# List of Greek letters to exclude
	EXCLUDED_LETTERS = {'ά', 'έ', 'ή', 'ί', 'ό', 'ύ', 'ώ', 'ϊ', 'ϋ', 'ΐ', 'ΰ', 'ς'}

	def detect_ampersand_changes(old_msgid, new_msgid):
	"""
	Detect if an ampersand (&) has been added or removed between old_msgid and new_msgid.
	Ignore escaped ampersands (&&).
	"""
	# Count non-escaped ampersands (&) by removing '&&' and counting remaining '&'
	old_ampersands = old_msgid.count('&') - old_msgid.count('&&') * 2
	new_ampersands = new_msgid.count('&') - new_msgid.count('&&') * 2

	if old_ampersands != new_ampersands:
	return old_ampersands, new_ampersands
	return old_ampersands, new_ampersands

	def remove_unescaped_ampersand(msgstr, count_to_remove):
	"""
	Remove only unescaped ampersands (&) from the string, leaving escaped ampersands (&&) intact.
	`count_to_remove` specifies how many ampersands to remove.
	"""
	result = []
	i = 0
	ampersands_removed = 0
	while i < len(msgstr):
	# Check for escaped ampersands (&&)
	if msgstr[i:i+2] == '&&':
	result.append('&&')
	i += 2 # Skip both '&'
	elif msgstr[i] == '&' and ampersands_removed < count_to_remove:
	# Remove the unescaped ampersand
	ampersands_removed += 1
	i += 1 # Skip this '&'
	else:
	result.append(msgstr[i])
	i += 1
	return ''.join(result)

	def apply_ampersand_change(old_msgid, new_msgid, msgstr):
	"""
	Apply the ampersand change to msgstr. If ampersand was removed, remove it from msgstr.
	If ampersand was added, assign it randomly to a letter in msgstr.
	"""
	old_ampersands, new_ampersands = detect_ampersand_changes(old_msgid, new_msgid)

	if new_ampersands > old_ampersands:
	# Ampersand added, assign it randomly
	ampersands_to_add = new_ampersands - old_ampersands
	return (True, assign_ampersand_randomly(msgstr, ampersands_to_add))
	elif old_ampersands > new_ampersands:
	# Ampersand removed, remove from msgstr
	return (True, remove_unescaped_ampersand(msgstr, old_ampersands - new_ampersands))
	elif new_ampersands > 0:
	# Ampersand's location moved.
	return (True, msgstr)
	return (False, msgstr)

	def assign_ampersand_randomly(msgstr, ampersands_to_add):
	"""
	Assign ampersands randomly to letters in msgstr.
	Penalize common Greek letters and exclude vowels with diacritics.
	"""
	# Filter out excluded vowels and create a list of unique letters in the msgstr
	unique_letters = [ch for ch in set(msgstr.lower()) if ch not in EXCLUDED_LETTERS and ch.isalpha()]

	if not unique_letters:
	# No valid letters to assign ampersands, return unchanged msgstr
	return msgstr

	# Create a list of letters with their penalties
	weighted_letters = []
	for letter in unique_letters:
	penalty = GREEK_LETTER_PENALTIES.get(letter, 1) # Higher penalty for common letters
	weighted_letters.extend([letter] * int(100 / penalty)) # More penalty = fewer chances

	# Randomly assign ampersands to letters in msgstr
	for _ in range(ampersands_to_add):
	chosen_letter = random.choice(weighted_letters)
	msgstr = insert_ampersand_before_letter(msgstr, chosen_letter)
	return msgstr

	def insert_ampersand_before_letter(msgstr, letter):
	"""Insert ampersand (&) before the first occurrence of the chosen letter (lowercase or uppercase) in msgstr."""
	lower_letter = letter.lower()
	upper_letter = letter.upper()

	lower_index = msgstr.find(lower_letter)
	upper_index = msgstr.find(upper_letter)

	if lower_index == -1 and upper_index == -1:
	return msgstr
	elif lower_index == -1 or (upper_index != -1 and upper_index < lower_index):
	return msgstr.replace(upper_letter, f'&{upper_letter}', 1)
	else:
	return msgstr.replace(lower_letter, f'&{lower_letter}', 1)

	def detect_trailing_changes(old, new):
	"""
	Detect if certain trailing characters like '...' have been added or removed
	between the old msgid and new msgid.
	"""
	# Define the trailing patterns to look for
	trailing_patterns = ['...', '…', ': ', ':', '.', ', ', ',']

	def find_trailing_pattern(s):
	for pattern in trailing_patterns:
	if s.endswith(pattern):
	return pattern
	return None

	old_trailing = find_trailing_pattern(old)
	new_trailing = find_trailing_pattern(new)

	if old_trailing != new_trailing:
	return old_trailing, new_trailing
	return None, None

	def apply_trailing_change(old_msgid, new_msgid, msgstr):
	"""
	Automatically apply trailing changes if the trailing pattern has been modified
	between old_msgid and new_msgid.
	"""
	old_trailing, new_trailing = detect_trailing_changes(old_msgid, new_msgid)
	if old_trailing is None and new_trailing is None:
	# No trailing changes detected
	return (False, msgstr)
	# Remove old trailing pattern from msgstr if it exists
	if old_trailing and msgstr.endswith(old_trailing):
	msgstr = msgstr[:-len(old_trailing)].rstrip()
	# Add the new trailing pattern to msgstr if a new one exists
	if new_trailing and not msgstr.endswith(new_trailing):
	msgstr = msgstr.rstrip() + new_trailing
	return (True, msgstr)

	def apply_case_change(old_msgid, new_msgid, msgstr):
	def sentence_case(s):
	return s[0].upper() + s[1:].lower()
	# Check if new_str is the sentence-cased version of old_msgid
	if sentence_case(old_msgid) == new_msgid:
	# Apply the same sentence casing to msg
	return (True, sentence_case(msgstr))
	if new_msgid[0].islower():
	# Apply lowercase to all letters in msgstr
	return (True, msgstr.lower())
	if old_msgid == sentence_case(new_msgid):
	# Words titled cased, ignore.
	return (True, msgstr)
	return (False, msgstr)

	def is_minor_change(old, new):
	"""
	Detect if the change is minor based on normalization (case, punctuation, whitespace changes).
	Return True if the change is minor.
	"""
	normalized_old = normalize_string(old)
	normalized_new = normalize_string(new)

	return normalized_old == normalized_new

	def normalize_string(s):
	"""Normalize a string by lowercasing, removing punctuation, and normalizing whitespace."""
	normalized = []
	prev_char = None
	# punctuation = string.punctuation + "…"
	punctuation = '.&:,…'
	for ch in s:
	if ch in punctuation:
	continue # Skip punctuation
	if ch.isspace():
	# Only append a single space when encountering multiple spaces
	if prev_char != ' ':
	normalized.append(' ')
	prev_char = ' '
	else:
	normalized.append(ch.lower())
	prev_char = ch.lower()
	return ''.join(normalized).strip()

	# def open_editor_with_content(initial_content):
	# """Open the user's default editor to edit multiline text."""
	# # Create a temporary file
	# with tempfile.NamedTemporaryFile(suffix=".tmp", mode='w+', delete=False) as tmp_file:
	# # Write initial content (the current msgstr) to the temporary file
	# tmp_file.write(initial_content)
	# tmp_file_name = tmp_file.name
	# # Try to get the user's default editor from environment variables, fallback to 'nano'
	# editor = os.environ.get('EDITOR', 'nano')
	# # Open the temporary file in the editor
	# subprocess.call([editor, tmp_file_name])
	# # After the user closes the editor, read the file back
	# with open(tmp_file_name, 'r') as tmp_file:
	# edited_content = tmp_file.read()
	# # Clean up the temporary file
	# os.remove(tmp_file_name)
	#
	# return edited_content.strip()

	def colored_inline_diff(str1, str2):
	# Create a SequenceMatcher object
	matcher = SequenceMatcher(None, str1, str2)
	# Process the diff
	for op, i1, i2, j1, j2 in matcher.get_opcodes():
	if op == 'equal':
	print(str1[i1:i2], end='')
	elif op == 'delete':
	print(colored(str1[i1:i2], 'white', 'on_red'), end='')
	elif op == 'insert':
	print(colored(str2[j1:j2], 'green'), end='')
	elif op == 'replace':
	print(colored(str1[i1:i2], 'white', 'on_red') + colored(str2[j1:j2], 'green'), end='')
	print() # Add a newline at the end

	def print_header(text):
	print(colored(f"\n=== {text} ===", "yellow", attrs=["bold"]))

	def print_subheader(text):
	print(colored(f" {text}", "cyan"))

	def print_info(text):
	print(colored(f"{text}", "magenta", attrs=["bold"]))

	def print_change(text):
	print(colored(f" {text}", "green"))

	def print_unchanged(text):
	print(colored(f" {text}", "dark_grey"))

	from enum import Enum

	class MsgstrChangeStatus(Enum):
	SAVED_AS_IS = 1 # When the entry was saved as is, without further changes
	AUTO_APPLIED = 2 # When the change was auto-applied to msgstr
	UNCHANGED = 3 # When no changes were applied

	def process_msgstr_change(current_msgstr, new_msgstr, change_applied):
	"""
	Process the changes to msgstr, returning the new msgstr and a status Enum representing the result.
	"""
	if new_msgstr != current_msgstr:
	return MsgstrChangeStatus.AUTO_APPLIED # Change is auto-applied
	elif change_applied:
	return MsgstrChangeStatus.SAVED_AS_IS # Entry saved as is
	else:
	return MsgstrChangeStatus.UNCHANGED # No changes applied

	def detect_and_preapply_changes(entry):
	"""
	Detect if the msgid or msgid_plural has added or removed trailing characters and apply the same change to msgstr_plural[0] (singular form)
	and msgstr_plural[1] (plural form). If the change is minor (punctuation, case, etc.), pre-apply it automatically.
	"""
	old_msgid = entry.previous_msgid
	new_msgid = entry.msgid
	old_msgid_plural = entry.previous_msgid_plural
	new_msgid_plural = entry.msgid_plural

	# Helper function to apply changes to msgstr (both singular and plural)
	def apply_changes_to_strs(old, new, msgstr):
	change_applied = False
	applied, new_msgstr = apply_ampersand_change(old, new, msgstr)
	change_applied = change_applied or applied
	applied, new_msgstr = apply_trailing_change(old, new, new_msgstr)
	change_applied = change_applied or applied
	applied, new_msgstr = apply_case_change(old, new, new_msgstr)
	change_applied = change_applied or applied
	return change_applied, new_msgstr

	is_minor_change_plural = bool(old_msgid_plural and new_msgid_plural) and \
	is_minor_change(old_msgid_plural, new_msgid_plural)
	# Handle singular and plural together if both exist
	if old_msgid and is_minor_change(old_msgid, new_msgid) and \
	bool(entry.msgstr_plural) == is_minor_change_plural: # XNOR
	print_subheader(f"Detected minor change in msgid:")
	colored_inline_diff(old_msgid, new_msgid)
	if is_minor_change_plural:
	colored_inline_diff(old_msgid_plural, new_msgid_plural)

	change_applied = False
	# Apply changes to the singular form
	applied, new_msgstr_singular = apply_changes_to_strs(
	old_msgid, new_msgid,
	entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr
	)
	change_applied = change_applied or applied

	status_singular = process_msgstr_change(
	entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr,
	new_msgstr_singular,
	change_applied or old_msgid == new_msgid
	)
	# If there is a plural form, apply changes to msgstr_plural[1]
	if entry.msgstr_plural and 1 in entry.msgstr_plural:
	applied, new_msgstr_plural = apply_changes_to_strs(old_msgid_plural,
	new_msgid_plural, entry.msgstr_plural[1])
	change_applied = change_applied or applied

	status_plural = process_msgstr_change(
	entry.msgstr_plural[1],
	new_msgstr_plural,
	change_applied or old_msgid_plural == new_msgid_plural
	)
	else:
	status_plural = MsgstrChangeStatus.SAVED_AS_IS

	if status_singular == MsgstrChangeStatus.UNCHANGED or \
	status_plural == MsgstrChangeStatus.UNCHANGED:
	print_unchanged("↳ Entry NOT changed:")
	print(new_msgstr_singular)
	if is_minor_change_plural:
	print(new_msgstr_plural)
	return False # Change is not minor, user will handle it

	if status_singular == MsgstrChangeStatus.AUTO_APPLIED:
	print_change("↳ Auto-applied change to entry:")
	colored_inline_diff(
	entry.msgstr_plural[0] if is_minor_change_plural else entry.msgstr,
	new_msgstr_singular
	)
	if is_minor_change_plural:
	colored_inline_diff(entry.msgstr_plural[1], new_msgstr_plural)
	elif status_singular == MsgstrChangeStatus.SAVED_AS_IS:
	print_change("↳ Entry saved as is:")
	print(new_msgstr_singular)
	if is_minor_change_plural:
	print(new_msgstr_plural)

	if status_singular == MsgstrChangeStatus.AUTO_APPLIED:
	if is_minor_change_plural:
	entry.msgstr_plural[0] = new_msgstr_singular
	entry.msgstr_plural[1] = new_msgstr_plural
	else:
	entry.msgstr = new_msgstr_singular
	else:
	print_unchanged(f"No changes applied due to complexity.")
	return False # Change is not minor, user will handle it

	def edit_msgstr(entry):
	"""Function to edit msgstr with multiline editing support and pre-applied changes."""
	# print(f"\nmsgid: {entry.msgid}")
	# if entry.previous_msgid:
	# print("\nDiff with previous_msgid:")
	# colored_inline_diff(entry.previous_msgid, entry.msgid)
	# Detect and pre-apply changes if msgid changed regarding trailing dots/ellipsis/colon/period
	detect_and_preapply_changes(entry)
	# # Show the current msgstr
	# print(f"\nCurrent msgstr: {entry.msgstr}")
	# # Prompt the user for action (edit, save, or skip)
	# while True:
	# action = input("Choose an action - [e]dit, [s]ave, or [k]skip: ").strip().lower()
	# if action == 'e':
	# # Open the user's editor with the current msgstr as the initial content
	# new_msgstr = open_editor_with_content(entry.msgstr)
	# # Update the msgstr if it was edited
	# if new_msgstr != entry.msgstr:
	# entry.msgstr = new_msgstr
	# print(f"\nUpdated msgstr: {entry.msgstr}")
	# break
	# elif action == 's':
	# # Just save the current msgstr (possibly pre-applied changes)
	# break
	# elif action == 'k':
	# # Skip saving changes
	# return False
	# return True

	def process_po_file(filepath):
	"""Process the .po file and handle fuzzy entries."""
	po = polib.pofile(filepath)
	changed = False

	for entry in po.fuzzy_entries():
	print_header(f"Editing fuzzy entry in {filepath}:{entry.linenum}")
	if edit_msgstr(entry):
	entry.flags.remove('fuzzy') # Remove the fuzzy flag
	changed = True

	if changed:
	print_info(f"Saving changes to {filepath}...")
	po.save()

	def scan_directory(directory):
	"""Scan the directory for .po files and process them."""
	for root, _, files in os.walk(directory):
	for file in files:
	if file.endswith('.po'):
	filepath = os.path.join(root, file)
	process_po_file(filepath)

	if __name__ == "__main__":
	directory = input("Enter the directory to scan for .po files: ").strip()
	scan_directory(directory)