Upload 3 files

english_phonetic_dict.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75aceecc03186feb38f8d2040873b475af440c01e00fc862e4ba41643b3e074d
+size 7490207

english_scansion_tool.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2dd099e8c5f43cc8b7bb5e44a0f4f6a2adb962d15deb5ed461054439f929bc4
+size 8088295

poetry_scansion_app.py

@@ -0,0 +1,241 @@
+# English Poetry Scansion Tool for macOS - v6.0 (Definitive)
+#
+# This definitive version incorporates a weighted scoring system for meter detection,
+# correctly prioritizing content words over function words. It also adds a new,
+# separate summary section for standard IPA phonetic transcriptions.
+#
+# This version should fix the scansion accuracy issues and fulfill all feature requests.
+# Author: Gemini
+# Date: October 1, 2025
+
+import tkinter as tk
+from tkinter import scrolledtext, messagebox, ttk
+import pickle
+import re
+import os
+
+class EnglishScansion:
+    def __init__(self, dict_path):
+        if not os.path.exists(dict_path):
+            raise FileNotFoundError(f"The dictionary file '{dict_path}' was not found. Please run the converter (v5) first.")
+        
+        with open(dict_path, 'rb') as f:
+            self.pronunciation_dict = pickle.load(f)
+
+        self.METERS = {'Iambic': '01', 'Trochaic': '10', 'Anapestic': '001', 'Dactylic': '100', 'Amphibrach': '010'}
+        self.VOWELS = "aeiouyAEIOUY"
+        self.ACCENT_MAP = {'a': 'á', 'e': 'é', 'i': 'í', 'o': 'ó', 'u': 'ú', 'y': 'ý',
+                           'A': 'Á', 'E': 'É', 'I': 'Í', 'O': 'Ó', 'U': 'Ú', 'Y': 'Ý'}
+        self.VOWEL_SOUNDS = re.compile(r'[A-Z]{2,3}[0-9]')
+        self.FUNCTION_WORDS = {
+            'a', 'an', 'the', 'and', 'but', 'or', 'for', 'nor', 'on', 'at', 'to', 'from',
+            'by', 'with', 'in', 'of', 'is', 'am', 'are', 'was', 'were', 'be', 'being',
+            'been', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'shall',
+            'should', 'can', 'could', 'may', 'might', 'must', 'as', 'if', 'so', 'my', 'your',
+            'his', 'her', 'its', 'our', 'their', 'me', 'you', 'him', 'her', 'it', 'us', 'them'
+        }
+
+    def get_word_data(self, word):
+        """Looks up a word and returns its processed data tuple and original IPA."""
+        lookup_word = word.lower().strip(".,;:!?()\"'")
+        if not lookup_word or lookup_word not in self.pronunciation_dict:
+            return None, f"<{lookup_word}>", 0, None
+
+        arpabet_list, ipa_raw = self.pronunciation_dict[lookup_word][0]
+        stress_pattern, syllable_count = "", 0
+
+        for phoneme in arpabet_list:
+            if self.VOWEL_SOUNDS.match(phoneme):
+                syllable_count += 1
+                stress_pattern += '1' if phoneme.endswith('1') or phoneme.endswith('2') else '0'
+        
+        return stress_pattern, ' '.join(arpabet_list), syllable_count, ipa_raw
+
+    def analyze_line(self, line):
+        words = re.findall(r"[\w']+|[.,!?;:]+", line)
+        
+        lexical_stress_pattern, word_map = "", []
+        
+        for word in words:
+            if re.match(r"[\w']+", word):
+                pattern, _, syllables, _ = self.get_word_data(word)
+                if pattern is not None:
+                    lexical_stress_pattern += pattern
+                    word_map.extend([word.lower()] * syllables)
+
+        line_syllables = len(lexical_stress_pattern)
+        if line_syllables == 0:
+            return {"original": line, "meter": "Unknown", "score": 1.0, "syllables": 0, "final_stress_pattern": ""}
+
+        # ** NEW WEIGHTED SCORING LOGIC **
+        scores = {}
+        for name, pattern in self.METERS.items():
+            template = (pattern * (line_syllables // len(pattern) + 1))[:line_syllables]
+            mismatch_score = 0
+            for i in range(line_syllables):
+                if lexical_stress_pattern[i] != template[i]:
+                    # Penalize mismatches on function words less
+                    weight = 0.5 if word_map[i] in self.FUNCTION_WORDS else 1.0
+                    mismatch_score += weight
+            scores[name] = mismatch_score / line_syllables
+        
+        best_meter_name = min(scores, key=scores.get)
+        best_meter_score = scores[best_meter_name]
+
+        winning_meter_pattern = self.METERS[best_meter_name]
+        final_stress_pattern = (winning_meter_pattern * (line_syllables // len(winning_meter_pattern) + 1))[:line_syllables]
+
+        foot_len = len(winning_meter_pattern)
+        num_feet = round(line_syllables / foot_len) if foot_len > 0 else 0
+        foot_map = {0:"0-foot", 1:"monometer", 2:"dimeter", 3:"trimeter", 4:"tetrameter", 5:"pentameter", 6:"hexameter"}
+        meter_desc = f"{best_meter_name} {foot_map.get(num_feet, f'{num_feet}-foot')}"
+
+        return {"original": line, "meter": meter_desc, "score": best_meter_score, "syllables": line_syllables, "final_stress_pattern": final_stress_pattern}
+
+    def format_line(self, line, analysis_result, format_type):
+        words = re.findall(r"[\w']+|[^\w']+", line)
+        output_parts = []
+
+        if format_type == 'arpabet' or format_type == 'ipa':
+            for word in words:
+                if re.match(r"[\w']+", word):
+                    _, arpabet, _, ipa = self.get_word_data(word)
+                    output_parts.append(ipa if format_type == 'ipa' and ipa else f"[{arpabet}]")
+                else:
+                    output_parts.append(word)
+            return " ".join(output_parts)
+
+        final_stress = analysis_result['final_stress_pattern']
+        syllable_cursor = 0
+        for word in words:
+            if not re.match(r"[\w']+", word):
+                output_parts.append(word)
+                continue
+
+            lexical_pattern, _, num_syllables, _ = self.get_word_data(word)
+            if lexical_pattern is None:
+                output_parts.append(f"<{word}>")
+                continue
+
+            word_stress_segment = final_stress[syllable_cursor : syllable_cursor + num_syllables]
+            
+            if format_type == 'plus':
+                output_parts.append(f"+{word}" if '1' in word_stress_segment else word)
+            elif format_type == 'accent':
+                temp_word = list(word)
+                vowel_groups = list(re.finditer(r'[aeiouy]+', word, re.IGNORECASE))
+                for i, stress_char in enumerate(word_stress_segment):
+                    if stress_char == '1' and i < len(vowel_groups):
+                        vowel_match = vowel_groups[i]
+                        pos = vowel_match.start()
+                        char_to_stress = temp_word[pos]
+                        temp_word[pos] = self.ACCENT_MAP.get(char_to_stress, char_to_stress)
+                output_parts.append("".join(temp_word))
+
+            syllable_cursor += num_syllables
+        
+        return " ".join(output_parts).replace(" ,", ",").replace(" .", ".").strip()
+
+class ScansionApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("English Poetry Scansion Tool")
+        self.root.geometry("1000x900")
+        self.VOWELS = "aeiouyAEIOUY"
+
+        self.style = ttk.Style()
+        try: self.style.theme_use('aqua')
+        except tk.TclError: self.style.theme_use('default')
+        self.style.configure('TFrame', background='#ECECEC')
+        self.style.configure('TButton', font=('Helvetica Neue', 13, 'bold'), padding=10)
+        self.style.configure('TLabel', font=('Helvetica Neue', 14), background='#ECECEC')
+        self.style.configure('Header.TLabel', font=('Helvetica Neue', 18, 'bold'))
+        
+        self.main_frame = ttk.Frame(root, padding="20")
+        self.main_frame.pack(fill=tk.BOTH, expand=True)
+
+        ttk.Label(self.main_frame, text="Poetry Scansion Analyzer", style='Header.TLabel').pack(pady=(0, 20))
+        self.input_text = scrolledtext.ScrolledText(self.main_frame, height=8, font=("Menlo", 12), wrap=tk.WORD)
+        self.input_text.pack(fill=tk.BOTH, expand=True, pady=5)
+        self.input_text.insert(tk.END, "But I will ignite\nIn your eyes a fire\nNow I give you strength\nNow I give you power")
+
+        ttk.Button(self.main_frame, text="Analyze Poem", command=self.perform_scan).pack(pady=15)
+
+        self.output_text = tk.Text(self.main_frame, font=("Menlo", 12), wrap=tk.WORD, background="black", relief=tk.SOLID, borderwidth=1, padx=10, pady=10)
+        self.output_text.pack(fill=tk.BOTH, expand=True, pady=5)
+        
+        self.output_text.tag_configure('vowel', foreground="#9370DB")
+        self.output_text.tag_configure('stressed_vowel', foreground="#FF474C", font=("Menlo", 12, "bold"))
+        self.output_text.tag_configure('consonant', foreground="#FFC700")
+        self.output_text.tag_configure('punctuation', foreground="#32CD32")
+        self.output_text.tag_configure('info', foreground="white")
+        self.output_text.tag_configure('separator', foreground="#555555")
+        self.output_text.tag_configure('header', foreground="white", font=("Menlo", 14, "bold", "underline"), justify='center')
+
+        self.output_text.config(state=tk.DISABLED)
+
+        try:
+            self.scanner = EnglishScansion(dict_path="english_phonetic_dict.pkl")
+        except Exception as e:
+            messagebox.showerror("Fatal Error", str(e))
+            self.root.destroy()
+
+    def perform_scan(self):
+        poem_text = self.input_text.get("1.0", tk.END)
+        if not poem_text.strip(): return
+
+        self.output_text.config(state=tk.NORMAL)
+        self.output_text.delete("1.0", tk.END)
+        
+        accented_poem_lines, ipa_poem_lines = [], []
+
+        for line in poem_text.strip().split('\n'):
+            if not line.strip():
+                self.output_text.insert(tk.END, '\n')
+                continue
+
+            analysis = self.scanner.analyze_line(line)
+            
+            accented_line = self.scanner.format_line(line, analysis, 'accent')
+            accented_poem_lines.append(accented_line)
+            ipa_poem_lines.append(self.scanner.format_line(line, analysis, 'ipa'))
+
+            self.render_color_line(self.scanner.format_line(line, analysis, 'plus') + "\n")
+            self.render_color_line(accented_line + "\n")
+            self.output_text.insert(tk.END, self.scanner.format_line(line, analysis, 'arpabet') + "\n", 'info')
+            
+            info_str = f"Meter: {analysis['meter']} | Syllables: {analysis['syllables']} | Mismatch Score: {analysis['score']:.2f}\n"
+            self.output_text.insert(tk.END, info_str, 'info')
+            self.output_text.insert(tk.END, "-" * 70 + "\n", 'separator')
+
+        # Render Summaries
+        self.output_text.insert(tk.END, "\n\n")
+        self.output_text.insert(tk.END, "Stressed Poem Summary\n", 'header')
+        self.output_text.insert(tk.END, "\n")
+        for line in accented_poem_lines:
+            self.render_color_line(line + "\n")
+
+        self.output_text.insert(tk.END, "\n\n")
+        self.output_text.insert(tk.END, "IPA Phonetic Transcription\n", 'header')
+        self.output_text.insert(tk.END, "\n")
+        for line in ipa_poem_lines:
+            self.output_text.insert(tk.END, line + "\n", 'info')
+
+        self.output_text.config(state=tk.DISABLED)
+
+    def render_color_line(self, text):
+        accented_vowels = "áéíóúýÁÉÍÓÚÝ"
+        for char in text:
+            tag = 'info'
+            if char in accented_vowels: tag = 'stressed_vowel'
+            elif char in self.VOWELS: tag = 'vowel'
+            elif char.isalpha(): tag = 'consonant'
+            elif char in "<>": tag = 'separator'
+            elif char in ".,;:!?'\"": tag = 'punctuation'
+            elif char == '+': tag = 'stressed_vowel'
+            self.output_text.insert(tk.END, char, tag)
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = ScansionApp(root)
+    root.mainloop()