damus

TranslateView.swift (7404B)

---

 //
 //  TranslateButton.swift
 //  damus
 //
 //  Created by William Casarin on 2023-02-02.
 //
 
 import SwiftUI
 import NaturalLanguage
 
 
 struct Translated: Equatable {
     let artifacts: NoteArtifactsSeparated
     let language: String
 }
 
 enum TranslateStatus: Equatable {
     case havent_tried
     case translating
     case translated(Translated)
     case not_needed
 }
 
 fileprivate let MIN_UNIQUE_CHARS = 2
 
 struct TranslateView: View {
     let damus_state: DamusState
     let event: NostrEvent
     let size: EventViewKind
     
     @ObservedObject var translations_model: TranslationModel
     
     init(damus_state: DamusState, event: NostrEvent, size: EventViewKind) {
         self.damus_state = damus_state
         self.event = event
         self.size = size
         self._translations_model = ObservedObject(wrappedValue: damus_state.events.get_cache_data(event.id).translations_model)
     }
     
     var TranslateButton: some View {
         Button(NSLocalizedString("Translate Note", comment: "Button to translate note from different language.")) {
             translate()
         }
         .translate_button_style()
     }
     
     func TranslatedView(lang: String?, artifacts: NoteArtifactsSeparated, font_size: Double) -> some View {
         return VStack(alignment: .leading) {
             let translatedFromLanguageString = String(format: NSLocalizedString("Translated from %@", comment: "Button to indicate that the note has been translated from a different language."), lang ?? "ja")
             Text(translatedFromLanguageString)
                 .foregroundColor(.gray)
                 .font(.footnote)
                 .padding([.top, .bottom], 10)
             
             if self.size == .selected {
                 SelectableText(attributedString: artifacts.content.attributed, size: self.size)
             } else {
                 artifacts.content.text
                     .font(eventviewsize_to_font(self.size, font_size: font_size))
             }
         }
     }
     
     func translate() {
         Task {
             guard let note_language = translations_model.note_language else {
                 return
             }
             let res = await translate_note(profiles: damus_state.profiles, keypair: damus_state.keypair, event: event, settings: damus_state.settings, note_lang: note_language, purple: damus_state.purple)
             DispatchQueue.main.async {
                 self.translations_model.state = res
             }
         }
     }
         
     func should_transl(_ note_lang: String) -> Bool {
         should_translate(event: event, our_keypair: damus_state.keypair, settings: damus_state.settings, note_lang: note_lang)
     }
     
     var body: some View {
         Group {
             switch self.translations_model.state {
             case .havent_tried:
                 if damus_state.settings.auto_translate {
                     Text("")
                 } else if let note_lang = translations_model.note_language, should_transl(note_lang)  {
                         TranslateButton
                 } else {
                     Text("")
                 }
             case .translating:
                 Text("")
             case .translated(let translated):
                 let languageName = Locale.current.localizedString(forLanguageCode: translated.language)
                 TranslatedView(lang: languageName, artifacts: translated.artifacts, font_size: damus_state.settings.font_size)
             case .not_needed:
                 Text("")
             }
         }
     }
     
     func translationMeetsStringDistanceRequirements(original: String, translated: String) -> Bool {
         return levenshteinDistanceIsGreaterThanOrEqualTo(from: original, to: translated, threshold: MIN_UNIQUE_CHARS)
     }
 }
 
 extension View {
     func translate_button_style() -> some View {
         return self
             .font(.footnote)
             .contentShape(Rectangle())
             .padding([.top, .bottom], 10)
     }
 }
 
 struct TranslateView_Previews: PreviewProvider {
     static var previews: some View {
         let ds = test_damus_state
         TranslateView(damus_state: ds, event: test_note, size: .normal)
     }
 }
 
 func translate_note(profiles: Profiles, keypair: Keypair, event: NostrEvent, settings: UserSettingsStore, note_lang: String, purple: DamusPurple) async -> TranslateStatus {
 
     // If the note language is different from our preferred languages, send a translation request.
     let translator = Translator(settings, purple: purple)
     let originalContent = event.get_content(keypair)
     let translated_note = try? await translator.translate(originalContent, from: note_lang, to: current_language())
     
     guard let translated_note else {
         // if its the same, give up and don't retry
         return .not_needed
     }
     
     guard originalContent != translated_note else {
         // if its the same, give up and don't retry
         return .not_needed
     }
     
     guard translationMeetsStringDistanceRequirements(original: originalContent, translated: translated_note) else {
         return .not_needed
     }
 
     // Render translated note
     let translated_blocks = parse_note_content(content: .content(translated_note, event.tags))
     let artifacts = render_blocks(blocks: translated_blocks, profiles: profiles)
     
     // and cache it
     return .translated(Translated(artifacts: artifacts, language: note_lang))
 }
 
 func current_language() -> String {
     if #available(iOS 16, *) {
         return Locale.current.language.languageCode?.identifier ?? "en"
     } else {
         return Locale.current.languageCode ?? "en"
     }
 }
     
 func levenshteinDistanceIsGreaterThanOrEqualTo(from source: String, to target: String, threshold: Int) -> Bool {
     let sourceCount = source.count
     let targetCount = target.count
     
     // Early return if the difference in lengths is already greater than or equal to the threshold,
     // indicating the edit distance meets the condition without further calculation.
     if abs(sourceCount - targetCount) >= threshold {
         return true
     }
     
     var matrix = [[Int]](repeating: [Int](repeating: 0, count: targetCount + 1), count: sourceCount + 1)
 
     for i in 0...sourceCount {
         matrix[i][0] = i
     }
 
     for j in 0...targetCount {
         matrix[0][j] = j
     }
 
     for i in 1...sourceCount {
         var rowMin = Int.max
         for j in 1...targetCount {
             let sourceIndex = source.index(source.startIndex, offsetBy: i - 1)
             let targetIndex = target.index(target.startIndex, offsetBy: j - 1)
 
             let cost = source[sourceIndex] == target[targetIndex] ? 0 : 1
             matrix[i][j] = min(
                 matrix[i - 1][j] + 1,    // Deletion
                 matrix[i][j - 1] + 1,    // Insertion
                 matrix[i - 1][j - 1] + cost  // Substitution
             )
             rowMin = min(rowMin, matrix[i][j])
         }
         // If the minimum edit distance found in any row is already greater than or equal to the threshold,
         // you can conclude the edit distance meets the criteria.
         if rowMin >= threshold {
             return true
         }
     }
 
     return matrix[sourceCount][targetCount] >= threshold
 }
 
 func translationMeetsStringDistanceRequirements(original: String, translated: String) -> Bool {
     return levenshteinDistanceIsGreaterThanOrEqualTo(from: original, to: translated, threshold: MIN_UNIQUE_CHARS)
 }