added char_syl_freq/

char_syl_freq/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py in char_syl_freq directory
+from .char_syl_freq import break_syllables, create_frequency_profile, save_profile, load_profiles, detect_language
+

char_syl_freq/char_syl_freq.py

@@ -0,0 +1,84 @@
+"""
+Approach: Language detection based on character and syllable frequency profiles
+
+The character score is calculated by summing the products of the frequency of each character in the input text and its frequency in the language profile. If a character is not found in the profile, its frequency is assumed to be zero.
+The syllable score is calculated in a similar way, using the frequencies of syllables.
+The character score and syllable score for each language are then combined to form a total score.
+After calculating the combined scores for all languages, the script identifies the language with the highest score as the detected language.
+
+Language profile format: JSON
+
+Written by Ye Kyaw Thu, LU Lab., Myanmar
+Last updated: 31 Jan 2024
+"""
+
+import argparse
+import os
+import json
+import re
+import sys
+from collections import Counter
+
+# Syllable segmentation functions and patterns
+my_consonant = "က-အ"
+en_char = "a-zA-Z0-9"
+other_char = "ဣဤဥဦဧဩဪဿ၌၍၏၀-၉၊။!-/:-@[-`{-~\s"
+subscript_symbol = '္'
+a_that = '်'
+break_pattern = re.compile(
+    r"((?<!" + subscript_symbol + r")[" + my_consonant + r"]"
+    r"(?!["
+    + a_that + subscript_symbol + r"])"
+    + r"|[" + en_char + other_char + r"])")
+
+def break_syllables(text, separator='|'):
+    text = re.sub(r'\s+', ' ', text.strip())
+    segmented_text = break_pattern.sub(separator + r"\1", text)
+    if segmented_text.startswith(separator):
+        segmented_text = segmented_text[len(separator):]
+    segmented_text = segmented_text.replace(separator + " ", " ")  # Ensure syllables are not concatenated
+    return segmented_text.split(separator)
+
+def create_frequency_profile(text):
+    # Character frequency
+    char_count = Counter(text)
+    total_chars = sum(char_count.values())
+    char_frequencies = {char: count / total_chars for char, count in char_count.items()}
+
+    # Syllable frequency
+    syllables = break_syllables(text)
+    syllable_count = Counter(syllables)
+    total_syllables = sum(syllable_count.values())
+    syllable_frequencies = {syl: count / total_syllables for syl, count in syllable_count.items()}
+
+    return {'char_freq': char_frequencies, 'syl_freq': syllable_frequencies}
+
+def save_profile(profile, output_path):
+    with open(output_path, 'w', encoding='utf-8') as file:
+        json.dump(profile, file)
+
+def load_profiles(profile_folder):
+    profiles = {}
+    for profile_file in os.listdir(profile_folder):
+        with open(os.path.join(profile_folder, profile_file), 'r', encoding='utf-8') as file:
+            profiles[profile_file] = json.load(file)
+    return profiles
+
+def detect_language(text, profiles):
+    # Perform both character and syllable segmentation
+    char_freq = {char: count / len(text) for char, count in Counter(text).items()}
+    syl_freq = {syl: count / len(break_syllables(text)) for syl, count in Counter(break_syllables(text)).items()}
+
+    scores = {}
+    for language, profile in profiles.items():
+        char_score = sum(char_freq.get(char, 0) * profile['char_freq'].get(char, 0) for char in char_freq)
+        syl_score = sum(syl_freq.get(syl, 0) * profile['syl_freq'].get(syl, 0) for syl in syl_freq)
+
+        # Combine scores (you can adjust the weightage as needed)
+        combined_score = (char_score + syl_score) / 2
+        scores[language] = combined_score
+
+    detected_language = max(scores, key=scores.get)
+    return detected_language
+
+