|
import re |
|
from jamo import h2j, j2hcj |
|
import ko_pron |
|
from g2pk2 import G2p |
|
|
|
g2pk = G2p() |
|
|
|
|
|
|
|
_korean_classifiers = 'κ΅°λ° κΆ κ° κ·Έλ£¨ λ’ λ λ λ§λ¦¬ λͺ¨ λͺ¨κΈ λ λ° λ°μ§ λ°© λ² λ² λ³΄λ£¨ μ΄ μ μ μ μ μνΌ μ μ§ μ± μ² μ²© μΆ μΌ€λ ν¨ ν΅' |
|
|
|
|
|
_hangul_divided = [(re.compile('%s' % x[0]), x[1]) for x in [ |
|
('γ³', 'γ±γ
'), |
|
('γ΅', 'γ΄γ
'), |
|
('γΆ', 'γ΄γ
'), |
|
('γΊ', 'γΉγ±'), |
|
('γ»', 'γΉγ
'), |
|
('γΌ', 'γΉγ
'), |
|
('γ½', 'γΉγ
'), |
|
('γΎ', 'γΉγ
'), |
|
('γΏ', 'γΉγ
'), |
|
('γ
', 'γΉγ
'), |
|
('γ
', 'γ
γ
'), |
|
('γ
', 'γ
γ
'), |
|
('γ
', 'γ
γ
'), |
|
('γ
', 'γ
γ
£'), |
|
('γ
', 'γ
γ
'), |
|
('γ
', 'γ
γ
'), |
|
('γ
', 'γ
γ
£'), |
|
('γ
’', 'γ
‘γ
£'), |
|
('γ
', 'γ
£γ
'), |
|
('γ
', 'γ
£γ
'), |
|
('γ
', 'γ
£γ
'), |
|
('γ
', 'γ
£γ
'), |
|
('γ
', 'γ
£γ
'), |
|
('γ
', 'γ
£γ
') |
|
]] |
|
|
|
|
|
_latin_to_hangul = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ |
|
('a', 'μμ΄'), |
|
('b', 'λΉ'), |
|
('c', 'μ'), |
|
('d', 'λ'), |
|
('e', 'μ΄'), |
|
('f', 'μν'), |
|
('g', 'μ§'), |
|
('h', 'μμ΄μΉ'), |
|
('i', 'μμ΄'), |
|
('j', 'μ μ΄'), |
|
('k', 'μΌμ΄'), |
|
('l', 'μ'), |
|
('m', 'μ '), |
|
('n', 'μ'), |
|
('o', 'μ€'), |
|
('p', 'νΌ'), |
|
('q', 'ν'), |
|
('r', 'μλ₯΄'), |
|
('s', 'μμ€'), |
|
('t', 'ν°'), |
|
('u', 'μ '), |
|
('v', 'λΈμ΄'), |
|
('w', 'λλΈμ '), |
|
('x', 'μμ€'), |
|
('y', 'μμ΄'), |
|
('z', 'μ νΈ') |
|
]] |
|
|
|
|
|
_ipa_to_lazy_ipa = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [ |
|
('tΝ‘Ι','Κ§'), |
|
('dΝ‘Κ','Κ₯'), |
|
('Ι²','n^'), |
|
('Ι','Κ'), |
|
('Κ·','w'), |
|
('Ι','l`'), |
|
('Κ','ΙΎ'), |
|
('Ι£','Ε'), |
|
('Ι°','Ι―'), |
|
('Κ','j'), |
|
('Κ','Ι'), |
|
('Ι‘','g'), |
|
('\u031a','#'), |
|
('\u0348','='), |
|
('\u031e',''), |
|
('\u0320',''), |
|
('\u0339','') |
|
]] |
|
|
|
|
|
def latin_to_hangul(text): |
|
for regex, replacement in _latin_to_hangul: |
|
text = re.sub(regex, replacement, text) |
|
return text |
|
|
|
|
|
def divide_hangul(text): |
|
text = j2hcj(h2j(text)) |
|
for regex, replacement in _hangul_divided: |
|
text = re.sub(regex, replacement, text) |
|
return text |
|
|
|
|
|
def hangul_number(num, sino=True): |
|
'''Reference https://github.com/Kyubyong/g2pK''' |
|
num = re.sub(',', '', num) |
|
|
|
if num == '0': |
|
return 'μ' |
|
if not sino and num == '20': |
|
return 'μ€λ¬΄' |
|
|
|
digits = '123456789' |
|
names = 'μΌμ΄μΌμ¬μ€μ‘μΉ νꡬ' |
|
digit2name = {d: n for d, n in zip(digits, names)} |
|
|
|
modifiers = 'ν λ μΈ λ€ λ€μ― μ¬μ― μΌκ³± μ¬λ μν' |
|
decimals = 'μ΄ μ€λ¬Ό μλ₯Έ λ§ν μ° μμ μΌν μ¬λ μν' |
|
digit2mod = {d: mod for d, mod in zip(digits, modifiers.split())} |
|
digit2dec = {d: dec for d, dec in zip(digits, decimals.split())} |
|
|
|
spelledout = [] |
|
for i, digit in enumerate(num): |
|
i = len(num) - i - 1 |
|
if sino: |
|
if i == 0: |
|
name = digit2name.get(digit, '') |
|
elif i == 1: |
|
name = digit2name.get(digit, '') + 'μ' |
|
name = name.replace('μΌμ', 'μ') |
|
else: |
|
if i == 0: |
|
name = digit2mod.get(digit, '') |
|
elif i == 1: |
|
name = digit2dec.get(digit, '') |
|
if digit == '0': |
|
if i % 4 == 0: |
|
last_three = spelledout[-min(3, len(spelledout)):] |
|
if ''.join(last_three) == '': |
|
spelledout.append('') |
|
continue |
|
else: |
|
spelledout.append('') |
|
continue |
|
if i == 2: |
|
name = digit2name.get(digit, '') + 'λ°±' |
|
name = name.replace('μΌλ°±', 'λ°±') |
|
elif i == 3: |
|
name = digit2name.get(digit, '') + 'μ²' |
|
name = name.replace('μΌμ²', 'μ²') |
|
elif i == 4: |
|
name = digit2name.get(digit, '') + 'λ§' |
|
name = name.replace('μΌλ§', 'λ§') |
|
elif i == 5: |
|
name = digit2name.get(digit, '') + 'μ' |
|
name = name.replace('μΌμ', 'μ') |
|
elif i == 6: |
|
name = digit2name.get(digit, '') + 'λ°±' |
|
name = name.replace('μΌλ°±', 'λ°±') |
|
elif i == 7: |
|
name = digit2name.get(digit, '') + 'μ²' |
|
name = name.replace('μΌμ²', 'μ²') |
|
elif i == 8: |
|
name = digit2name.get(digit, '') + 'μ΅' |
|
elif i == 9: |
|
name = digit2name.get(digit, '') + 'μ' |
|
elif i == 10: |
|
name = digit2name.get(digit, '') + 'λ°±' |
|
elif i == 11: |
|
name = digit2name.get(digit, '') + 'μ²' |
|
elif i == 12: |
|
name = digit2name.get(digit, '') + 'μ‘°' |
|
elif i == 13: |
|
name = digit2name.get(digit, '') + 'μ' |
|
elif i == 14: |
|
name = digit2name.get(digit, '') + 'λ°±' |
|
elif i == 15: |
|
name = digit2name.get(digit, '') + 'μ²' |
|
spelledout.append(name) |
|
return ''.join(elem for elem in spelledout) |
|
|
|
|
|
def number_to_hangul(text): |
|
'''Reference https://github.com/Kyubyong/g2pK''' |
|
tokens = set(re.findall(r'(\d[\d,]*)([\uac00-\ud71f]+)', text)) |
|
for token in tokens: |
|
num, classifier = token |
|
if classifier[:2] in _korean_classifiers or classifier[0] in _korean_classifiers: |
|
spelledout = hangul_number(num, sino=False) |
|
else: |
|
spelledout = hangul_number(num, sino=True) |
|
text = text.replace(f'{num}{classifier}', f'{spelledout}{classifier}') |
|
|
|
digits = '0123456789' |
|
names = 'μμΌμ΄μΌμ¬μ€μ‘μΉ νꡬ' |
|
for d, n in zip(digits, names): |
|
text = text.replace(d, n) |
|
return text |
|
|
|
|
|
def korean_to_lazy_ipa(text): |
|
text = latin_to_hangul(text) |
|
text = number_to_hangul(text) |
|
text=re.sub('[\uac00-\ud7af]+',lambda x:ko_pron.romanise(x.group(0),'ipa').split('] ~ [')[0],text) |
|
for regex, replacement in _ipa_to_lazy_ipa: |
|
text = re.sub(regex, replacement, text) |
|
return text |
|
|
|
|
|
def korean_to_ipa(text): |
|
text = korean_to_lazy_ipa(text) |
|
return text.replace('Κ§','tΚ').replace('Κ₯','dΚ') |
|
|
|
def korean_to_ipa2(text): |
|
text = latin_to_hangul(text) |
|
text = number_to_hangul(text) |
|
text = g2pk(text) |
|
text=re.sub('[\uac00-\ud7af]+',lambda x:ko_pron.romanise(x.group(0),'ipa').split('] ~ [')[0],text) |
|
for regex, replacement in _ipa_to_lazy_ipa: |
|
text = re.sub(regex, replacement, text) |
|
text = text.replace('Κ§','tΚ').replace('Κ₯','dΚ') |
|
return text |
|
|
|
|
|
|
|
|
|
|
|
|
|
import itertools |
|
|
|
INITIAL = 0x001 |
|
MEDIAL = 0x010 |
|
FINAL = 0x100 |
|
CHAR_LISTS = { |
|
INITIAL: list(map(chr, [ |
|
0x3131, 0x3132, 0x3134, 0x3137, 0x3138, 0x3139, |
|
0x3141, 0x3142, 0x3143, 0x3145, 0x3146, 0x3147, |
|
0x3148, 0x3149, 0x314a, 0x314b, 0x314c, 0x314d, |
|
0x314e |
|
])), |
|
MEDIAL: list(map(chr, [ |
|
0x314f, 0x3150, 0x3151, 0x3152, 0x3153, 0x3154, |
|
0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315a, |
|
0x315b, 0x315c, 0x315d, 0x315e, 0x315f, 0x3160, |
|
0x3161, 0x3162, 0x3163 |
|
])), |
|
FINAL: list(map(chr, [ |
|
0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, |
|
0x3137, 0x3139, 0x313a, 0x313b, 0x313c, 0x313d, |
|
0x313e, 0x313f, 0x3140, 0x3141, 0x3142, 0x3144, |
|
0x3145, 0x3146, 0x3147, 0x3148, 0x314a, 0x314b, |
|
0x314c, 0x314d, 0x314e |
|
])) |
|
} |
|
CHAR_INITIALS = CHAR_LISTS[INITIAL] |
|
CHAR_MEDIALS = CHAR_LISTS[MEDIAL] |
|
CHAR_FINALS = CHAR_LISTS[FINAL] |
|
CHAR_SETS = {k: set(v) for k, v in CHAR_LISTS.items()} |
|
CHARSET = set(itertools.chain(*CHAR_SETS.values())) |
|
CHAR_INDICES = {k: {c: i for i, c in enumerate(v)} |
|
for k, v in CHAR_LISTS.items()} |
|
|
|
|
|
def is_hangul_syllable(c): |
|
return 0xac00 <= ord(c) <= 0xd7a3 |
|
|
|
|
|
def is_hangul_jamo(c): |
|
return 0x1100 <= ord(c) <= 0x11ff |
|
|
|
|
|
def is_hangul_compat_jamo(c): |
|
return 0x3130 <= ord(c) <= 0x318f |
|
|
|
|
|
def is_hangul_jamo_exta(c): |
|
return 0xa960 <= ord(c) <= 0xa97f |
|
|
|
|
|
def is_hangul_jamo_extb(c): |
|
return 0xd7b0 <= ord(c) <= 0xd7ff |
|
|
|
|
|
def is_hangul(c): |
|
return (is_hangul_syllable(c) or |
|
is_hangul_jamo(c) or |
|
is_hangul_compat_jamo(c) or |
|
is_hangul_jamo_exta(c) or |
|
is_hangul_jamo_extb(c)) |
|
|
|
|
|
def is_supported_hangul(c): |
|
return is_hangul_syllable(c) or is_hangul_compat_jamo(c) |
|
|
|
|
|
def check_hangul(c, jamo_only=False): |
|
if not ((jamo_only or is_hangul_compat_jamo(c)) or is_supported_hangul(c)): |
|
raise ValueError(f"'{c}' is not a supported hangul character. " |
|
f"'Hangul Syllables' (0xac00 ~ 0xd7a3) and " |
|
f"'Hangul Compatibility Jamos' (0x3130 ~ 0x318f) are " |
|
f"supported at the moment.") |
|
|
|
|
|
def get_jamo_type(c): |
|
check_hangul(c) |
|
assert is_hangul_compat_jamo(c), f"not a jamo: {ord(c):x}" |
|
return sum(t for t, s in CHAR_SETS.items() if c in s) |
|
|
|
|
|
def split_syllable_char(c): |
|
""" |
|
Splits a given korean syllable into its components. Each component is |
|
represented by Unicode in 'Hangul Compatibility Jamo' range. |
|
|
|
Arguments: |
|
c: A Korean character. |
|
|
|
Returns: |
|
A triple (initial, medial, final) of Hangul Compatibility Jamos. |
|
If no jamo corresponds to a position, `None` is returned there. |
|
|
|
Example: |
|
>>> split_syllable_char("μ") |
|
("γ
", "γ
", "γ΄") |
|
>>> split_syllable_char("κ³ ") |
|
("γ±", "γ
", None) |
|
>>> split_syllable_char("γ
") |
|
(None, "γ
", None) |
|
>>> split_syllable_char("γ
") |
|
("γ
", None, None) |
|
""" |
|
check_hangul(c) |
|
if len(c) != 1: |
|
raise ValueError("Input string must have exactly one character.") |
|
|
|
init, med, final = None, None, None |
|
if is_hangul_syllable(c): |
|
offset = ord(c) - 0xac00 |
|
x = (offset - offset % 28) // 28 |
|
init, med, final = x // 21, x % 21, offset % 28 |
|
if not final: |
|
final = None |
|
else: |
|
final -= 1 |
|
else: |
|
pos = get_jamo_type(c) |
|
if pos & INITIAL == INITIAL: |
|
pos = INITIAL |
|
elif pos & MEDIAL == MEDIAL: |
|
pos = MEDIAL |
|
elif pos & FINAL == FINAL: |
|
pos = FINAL |
|
idx = CHAR_INDICES[pos][c] |
|
if pos == INITIAL: |
|
init = idx |
|
elif pos == MEDIAL: |
|
med = idx |
|
else: |
|
final = idx |
|
return tuple(CHAR_LISTS[pos][idx] if idx is not None else None |
|
for pos, idx in |
|
zip([INITIAL, MEDIAL, FINAL], [init, med, final])) |
|
|
|
|
|
def split_syllables(s, ignore_err=True, pad=None): |
|
""" |
|
Performs syllable-split on a string. |
|
|
|
Arguments: |
|
s (str): A string (possibly mixed with non-Hangul characters). |
|
ignore_err (bool): If set False, it ensures that all characters in |
|
the string are Hangul-splittable and throws a ValueError otherwise. |
|
(default: True) |
|
pad (str): Pad empty jamo positions (initial, medial, or final) with |
|
`pad` character. This is useful for cases where fixed-length |
|
strings are needed. (default: None) |
|
|
|
Returns: |
|
Hangul-split string |
|
|
|
Example: |
|
>>> split_syllables("μλ
νμΈμ") |
|
"γ
γ
γ΄γ΄γ
γ
γ
γ
γ
γ
γ
γ
" |
|
>>> split_syllables("μλ
νμΈμ~~", ignore_err=False) |
|
ValueError: encountered an unsupported character: ~ (0x7e) |
|
>>> split_syllables("μλ
νμΈμγ
", pad="x") |
|
'γ
γ
γ΄γ΄γ
γ
γ
γ
xγ
γ
xγ
γ
xxγ
x' |
|
""" |
|
|
|
def try_split(c): |
|
try: |
|
return split_syllable_char(c) |
|
except ValueError: |
|
if ignore_err: |
|
return (c,) |
|
raise ValueError(f"encountered an unsupported character: " |
|
f"{c} (0x{ord(c):x})") |
|
|
|
s = map(try_split, s) |
|
if pad is not None: |
|
tuples = map(lambda x: tuple(pad if y is None else y for y in x), s) |
|
else: |
|
tuples = map(lambda x: filter(None, x), s) |
|
return "".join(itertools.chain(*tuples)) |
|
|
|
|
|
def join_jamos_char(init, med, final=None): |
|
""" |
|
Combines jamos into a single syllable. |
|
|
|
Arguments: |
|
init (str): Initial jao. |
|
med (str): Medial jamo. |
|
final (str): Final jamo. If not supplied, the final syllable is made |
|
without the final. (default: None) |
|
|
|
Returns: |
|
A Korean syllable. |
|
""" |
|
chars = (init, med, final) |
|
for c in filter(None, chars): |
|
check_hangul(c, jamo_only=True) |
|
|
|
idx = tuple(CHAR_INDICES[pos][c] if c is not None else c |
|
for pos, c in zip((INITIAL, MEDIAL, FINAL), chars)) |
|
init_idx, med_idx, final_idx = idx |
|
|
|
|
|
final_idx = 0 if final_idx is None else final_idx + 1 |
|
return chr(0xac00 + 28 * 21 * init_idx + 28 * med_idx + final_idx) |
|
|
|
|
|
def join_jamos(s, ignore_err=True): |
|
""" |
|
Combines a sequence of jamos to produce a sequence of syllables. |
|
|
|
Arguments: |
|
s (str): A string (possible mixed with non-jamo characters). |
|
ignore_err (bool): If set False, it will ensure that all characters |
|
will be consumed for the making of syllables. It will throw a |
|
ValueError when it fails to do so. (default: True) |
|
|
|
Returns: |
|
A string |
|
|
|
Example: |
|
>>> join_jamos("γ
γ
γ΄γ΄γ
γ
γ
γ
γ
γ
γ
γ
") |
|
"μλ
νμΈμ" |
|
>>> join_jamos("γ
γ
γ΄γ΄γ΄γ
γ
γ
γ
γ
γ
γ
γ
") |
|
"μγ΄λ
νμΈμ" |
|
>>> join_jamos() |
|
""" |
|
last_t = 0 |
|
queue = [] |
|
new_string = "" |
|
|
|
def flush(n=0): |
|
new_queue = [] |
|
while len(queue) > n: |
|
new_queue.append(queue.pop()) |
|
if len(new_queue) == 1: |
|
if not ignore_err: |
|
raise ValueError(f"invalid jamo character: {new_queue[0]}") |
|
result = new_queue[0] |
|
elif len(new_queue) >= 2: |
|
try: |
|
result = join_jamos_char(*new_queue) |
|
except (ValueError, KeyError): |
|
|
|
if not ignore_err: |
|
raise ValueError(f"invalid jamo characters: {new_queue}") |
|
result = "".join(new_queue) |
|
else: |
|
result = None |
|
return result |
|
|
|
for c in s: |
|
if c not in CHARSET: |
|
if queue: |
|
new_c = flush() + c |
|
else: |
|
new_c = c |
|
last_t = 0 |
|
else: |
|
t = get_jamo_type(c) |
|
new_c = None |
|
if t & FINAL == FINAL: |
|
if not (last_t == MEDIAL): |
|
new_c = flush() |
|
elif t == INITIAL: |
|
new_c = flush() |
|
elif t == MEDIAL: |
|
if last_t & INITIAL == INITIAL: |
|
new_c = flush(1) |
|
else: |
|
new_c = flush() |
|
last_t = t |
|
queue.insert(0, c) |
|
if new_c: |
|
new_string += new_c |
|
if queue: |
|
new_string += flush() |
|
return new_string |