hangulpy 1.0.0__tar.gz

hangulpy-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 gaon12
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hangulpy-1.0.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: hangulpy
+Version: 1.0.0
+Summary: A Python library for processing Hangul, inspired by es-hangul.
+Home-page: https://github.com/gaon12/hangulpy
+Author: Jeong Gaon
+Author-email: gokirito12@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# hangulpy
+
+hangulpy는 한글 처리를 위한 파이썬 라이브러리입니다. es-hangul의 파이썬 버전으로, 초성 검색과 조사 붙이기 등의 기능을 제공합니다.
+
+## 설치
+
+```bash
+pip install hangulpy
+```
+
+## 사용법
+
+### 초성 검색
+
+```python
+from hangulpy import chosungIncludes
+
+searchWord = '라면'
+userInput = 'ㄹㅁ'
+
+result = chosungIncludes(searchWord, userInput)
+print(result)  # True
+```
+
+### 조사 붙이기
+
+```python
+from hangulpy import josa
+
+word1 = '사과'
+sentence1 = josa(word1, '을/를') + ' 먹었습니다.'
+print(sentence1)  # '사과를 먹었습니다.'
+
+word2 = '바나나'
+sentence2 = josa(word2, '이/가') + ' 맛있습니다.'
+print(sentence2)  # '바나나가 맛있습니다.'
+```
+
+### 자음 또는 모음 여부
+
+```python
+from hangulpy import is_hangul_consonant, is_hangul_vowel
+
+char1 = 'ㄱ'
+char2 = 'ㅏ'
+
+print(is_hangul_consonant('ㄱ'))  # True
+print(is_hangul_consonant('ㅏ'))  # False
+print(is_hangul_vowel('ㅏ'))  # True
+print(is_hangul_vowel('ㄱ'))  # False
+```
+
+### 문자열 포함 여부 확인
+
+```python
+from hangulpy import hangul_contains
+
+word = '사과'
+print(hangul_contains(word, ''))  # True
+print(hangul_contains(word, '', notallowempty=True))  # False
+print(hangul_contains(word, 'ㅅ'))  # True
+print(hangul_contains(word, '삭'))  # True
+print(hangul_contains(word, '삽'))  # False
+print(hangul_contains(word, '사과'))  # True
+
+# 문장처럼 입력 값 사이에 공백이 포함된 경우
+print(hangul_contains('사과는 맛있다', '사과는 ㅁ'))  # True
+print(hangul_contains('사과는 맛있다', '사과는 '))  # True
+```
+
+### 초/중/종성 분해(문자열 변환)
+```python
+from hangulpy import decompose_hangul_char
+
+char = '괜'
+print(decompose_hangul_char(char))  # ('ㄱ', ('ㅗ', 'ㅐ'), ('ㄴ', 'ㅈ'))
+```
+
+#### 분해 시 배열로 반환
+```python
+char1 = '값'
+print(split_hangul_char(char1))  # ['ㄱ', 'ㅏ', 'ㅂ', 'ㅅ']
+
+char2 = 'ㅘ'
+print(split_hangul_char(char2))  # ['ㅗ', 'ㅏ']
+
+char3 = 'ㄵ'
+print(split_hangul_char(char3))  # ['ㄴ', 'ㅈ']
+```
+
+### 자음으로 끝나는지 확인
+```python
+from hangulpy import ends_with_consonant
+
+print(ends_with_consonant('강'))  # False
+print(ends_with_consonant('각'))  # True
+print(ends_with_consonant('ㄱ'))  # True
+print(ends_with_consonant('ㅏ'))  # False
+print(ends_with_consonant('a'))  # False
+print(ends_with_consonant('한'))  # True
+print(ends_with_consonant('하'))  # False
+```
+
+### 초성 또는 종성으로 쓰일 수 있는지 확인
+```python
+from hangulpy import can_be_chosung, can_be_jongsung
+
+print(can_be_chosung('ㄱ'))  # True
+print(can_be_chosung('ㄳ'))  # False
+print(can_be_chosung('ㄸ'))  # True
+print(can_be_jongsung('ㄲ'))  # True
+print(can_be_jongsung('ㄸ'))  # False
+print(can_be_jongsung('ㄳ'))  # True
+```
+
+### 숫자 읽기
+```python
+from hangulpy import number_to_hangul, hangul_to_number
+
+print(number_to_hangul(1234))  # 천이백삼십사
+print(number_to_hangul(3.1415926))  # 삼 점 일사일오구이육
+print(hangul_to_number("천이백삼십사"))  # 1234
+print(hangul_to_number("삼점일사일오구이육"))  # 3.1415926
+```

hangulpy-1.0.0/README.md

@@ -0,0 +1,124 @@
+# hangulpy
+
+hangulpy는 한글 처리를 위한 파이썬 라이브러리입니다. es-hangul의 파이썬 버전으로, 초성 검색과 조사 붙이기 등의 기능을 제공합니다.
+
+## 설치
+
+```bash
+pip install hangulpy
+```
+
+## 사용법
+
+### 초성 검색
+
+```python
+from hangulpy import chosungIncludes
+
+searchWord = '라면'
+userInput = 'ㄹㅁ'
+
+result = chosungIncludes(searchWord, userInput)
+print(result)  # True
+```
+
+### 조사 붙이기
+
+```python
+from hangulpy import josa
+
+word1 = '사과'
+sentence1 = josa(word1, '을/를') + ' 먹었습니다.'
+print(sentence1)  # '사과를 먹었습니다.'
+
+word2 = '바나나'
+sentence2 = josa(word2, '이/가') + ' 맛있습니다.'
+print(sentence2)  # '바나나가 맛있습니다.'
+```
+
+### 자음 또는 모음 여부
+
+```python
+from hangulpy import is_hangul_consonant, is_hangul_vowel
+
+char1 = 'ㄱ'
+char2 = 'ㅏ'
+
+print(is_hangul_consonant('ㄱ'))  # True
+print(is_hangul_consonant('ㅏ'))  # False
+print(is_hangul_vowel('ㅏ'))  # True
+print(is_hangul_vowel('ㄱ'))  # False
+```
+
+### 문자열 포함 여부 확인
+
+```python
+from hangulpy import hangul_contains
+
+word = '사과'
+print(hangul_contains(word, ''))  # True
+print(hangul_contains(word, '', notallowempty=True))  # False
+print(hangul_contains(word, 'ㅅ'))  # True
+print(hangul_contains(word, '삭'))  # True
+print(hangul_contains(word, '삽'))  # False
+print(hangul_contains(word, '사과'))  # True
+
+# 문장처럼 입력 값 사이에 공백이 포함된 경우
+print(hangul_contains('사과는 맛있다', '사과는 ㅁ'))  # True
+print(hangul_contains('사과는 맛있다', '사과는 '))  # True
+```
+
+### 초/중/종성 분해(문자열 변환)
+```python
+from hangulpy import decompose_hangul_char
+
+char = '괜'
+print(decompose_hangul_char(char))  # ('ㄱ', ('ㅗ', 'ㅐ'), ('ㄴ', 'ㅈ'))
+```
+
+#### 분해 시 배열로 반환
+```python
+char1 = '값'
+print(split_hangul_char(char1))  # ['ㄱ', 'ㅏ', 'ㅂ', 'ㅅ']
+
+char2 = 'ㅘ'
+print(split_hangul_char(char2))  # ['ㅗ', 'ㅏ']
+
+char3 = 'ㄵ'
+print(split_hangul_char(char3))  # ['ㄴ', 'ㅈ']
+```
+
+### 자음으로 끝나는지 확인
+```python
+from hangulpy import ends_with_consonant
+
+print(ends_with_consonant('강'))  # False
+print(ends_with_consonant('각'))  # True
+print(ends_with_consonant('ㄱ'))  # True
+print(ends_with_consonant('ㅏ'))  # False
+print(ends_with_consonant('a'))  # False
+print(ends_with_consonant('한'))  # True
+print(ends_with_consonant('하'))  # False
+```
+
+### 초성 또는 종성으로 쓰일 수 있는지 확인
+```python
+from hangulpy import can_be_chosung, can_be_jongsung
+
+print(can_be_chosung('ㄱ'))  # True
+print(can_be_chosung('ㄳ'))  # False
+print(can_be_chosung('ㄸ'))  # True
+print(can_be_jongsung('ㄲ'))  # True
+print(can_be_jongsung('ㄸ'))  # False
+print(can_be_jongsung('ㄳ'))  # True
+```
+
+### 숫자 읽기
+```python
+from hangulpy import number_to_hangul, hangul_to_number
+
+print(number_to_hangul(1234))  # 천이백삼십사
+print(number_to_hangul(3.1415926))  # 삼 점 일사일오구이육
+print(hangul_to_number("천이백삼십사"))  # 1234
+print(hangul_to_number("삼점일사일오구이육"))  # 3.1415926
+```

hangulpy-1.0.0/hangulpy/__init__.py

@@ -0,0 +1,11 @@
+# hangulpy/__init__.py
+
+from .chosung import chosungIncludes, get_chosung
+from .hangul_check import is_hangul_consonant, is_hangul_vowel
+from .hangul_contains import hangul_contains
+from .hangul_decompose import decompose_hangul_char
+from .hangul_ends_with_consonant import ends_with_consonant
+from .hangul_number import float_to_hangul, hangul_to_number, number_to_hangul
+from .hangul_role import can_be_chosung, can_be_jongsung
+from .hangul_split import split_hangul_char
+from .josa import has_jongsung, josa

hangulpy-1.0.0/hangulpy/chosung.py

@@ -0,0 +1,29 @@
+# chosung.py
+
+from hangulpy.utils import CHOSUNG_LIST, CHOSUNG_BASE, is_hangul_char, HANGUL_BEGIN_UNICODE
+
+def get_chosung(c):
+    """
+    주어진 한글 음절의 초성을 반환합니다.
+    
+    :param c: 한글 음절 문자
+    :return: 초성 문자 (한글이 아니면 그대로 반환)
+    """
+    if is_hangul_char(c):
+        char_index = ord(c) - HANGUL_BEGIN_UNICODE
+        chosung_index = char_index // CHOSUNG_BASE
+        return CHOSUNG_LIST[chosung_index]
+    return c
+
+def chosungIncludes(word, pattern):
+    """
+    주어진 단어에 패턴의 초성이 포함되어 있는지 확인합니다.
+    
+    :param word: 검색할 단어
+    :param pattern: 검색할 초성 패턴
+    :return: 패턴이 단어의 초성에 포함되어 있으면 True, 아니면 False
+    """
+    # 단어의 각 문자를 초성으로 변환하여 문자열을 생성합니다.
+    word_chosung = ''.join(get_chosung(c) for c in word)
+    # 패턴이 초성 문자열에 포함되어 있는지 확인합니다.
+    return pattern in word_chosung

hangulpy-1.0.0/hangulpy/hangul_check.py

@@ -0,0 +1,21 @@
+# hangul_check.py
+
+from hangulpy.utils import CHOSUNG_LIST, JUNGSUNG_LIST
+
+def is_hangul_consonant(char):
+    """
+    주어진 문자가 한글 자음인지 확인합니다.
+    
+    :param char: 확인할 문자
+    :return: 한글 자음이면 True, 아니면 False
+    """
+    return char in CHOSUNG_LIST
+
+def is_hangul_vowel(char):
+    """
+    주어진 문자가 한글 모음인지 확인합니다.
+    
+    :param char: 확인할 문자
+    :return: 한글 모음이면 True, 아니면 False
+    """
+    return char in JUNGSUNG_LIST

hangulpy-1.0.0/hangulpy/hangul_contains.py

@@ -0,0 +1,22 @@
+# hangul_contains.py
+
+from hangulpy.utils import is_hangul_char
+from hangulpy.hangul_split import split_hangul_char
+
+def hangul_contains(word, pattern, notallowempty=False):
+    """
+    주어진 한글 문자열이 다른 한글 문자열을 포함하는지 검사합니다.
+    
+    :param word: 검사할 한글 문자열
+    :param pattern: 포함 여부를 검사할 한글 문자열 패턴
+    :param notallowempty: 패턴이 빈 문자열일 때 false를 반환하는 옵션
+    :return: 포함되면 True, 아니면 False
+    """
+    if not pattern:
+        return not notallowempty
+    
+    # 문자열을 분해하여 리스트로 변환
+    word_split = ''.join(''.join(split_hangul_char(char)) for char in word)
+    pattern_split = ''.join(''.join(split_hangul_char(char)) for char in pattern)
+    
+    return pattern_split in word_split

hangulpy-1.0.0/hangulpy/hangul_decompose.py

@@ -0,0 +1,28 @@
+# hangul_decompose.py
+
+from hangulpy.utils import CHOSUNG_LIST, CHOSUNG_BASE, is_hangul_char, HANGUL_BEGIN_UNICODE, JUNGSUNG_LIST, JUNGSUNG_DECOMPOSE, JONGSUNG_LIST, JONGSUNG_DECOMPOSE, JUNGSUNG_BASE
+
+def decompose_hangul_char(c):
+    """
+    주어진 한글 음절을 초성, 중성, 종성으로 분해합니다.
+    
+    :param c: 한글 음절 문자
+    :return: (초성, 중성, 종성) 튜플
+    """
+    if is_hangul_char(c):
+        # 한글 음절의 유니코드 값을 기준으로 각 성분의 인덱스를 계산합니다.
+        char_index = ord(c) - HANGUL_BEGIN_UNICODE
+        chosung_index = char_index // CHOSUNG_BASE
+        jungsung_index = (char_index % CHOSUNG_BASE) // JUNGSUNG_BASE
+        jongsung_index = char_index % JUNGSUNG_BASE
+        
+        # 중성 및 종성 분해
+        jungsung = JUNGSUNG_LIST[jungsung_index]
+        jongsung = JONGSUNG_LIST[jongsung_index]
+
+        jungsung_decomposed = JUNGSUNG_DECOMPOSE.get(jungsung, (jungsung,))
+        jongsung_decomposed = JONGSUNG_DECOMPOSE.get(jongsung, (jongsung,))
+        
+        return (CHOSUNG_LIST[chosung_index], jungsung_decomposed, jongsung_decomposed)
+    
+    return (c, '', '')  # 한글이 아니면 그대로 반환

hangulpy-1.0.0/hangulpy/hangul_ends_with_consonant.py

@@ -0,0 +1,19 @@
+# hangul_ends_with_consonant.py
+
+from hangulpy.utils import is_hangul_char, HANGUL_BEGIN_UNICODE, CHOSUNG_LIST, JONGSUNG_LIST
+
+def ends_with_consonant(char):
+    """
+    주어진 문자가 자음으로 끝나는지 확인합니다.
+    
+    :param char: 확인할 문자
+    :return: 자음으로 끝나면 True, 아니면 False
+    """
+    if not is_hangul_char(char):
+        return char in CHOSUNG_LIST
+
+    # 한글 음절의 유니코드 값을 기준으로 종성 인덱스를 확인합니다.
+    char_index = ord(char) - HANGUL_BEGIN_UNICODE
+    jongsung_index = char_index % 28  # 28개의 종성
+
+    return JONGSUNG_LIST[jongsung_index] != ''

hangulpy-1.0.0/hangulpy/hangul_number.py

@@ -0,0 +1,98 @@
+# hangul_number.py
+
+from hangulpy.utils import UNITS, NUMBERS
+
+def number_to_hangul(num):
+    """
+    주어진 숫자를 한글로 변환합니다.
+    
+    :param num: 변환할 숫자
+    :return: 한글 숫자 문자열
+    """
+    if num == 0:
+        return "영"
+    
+    if isinstance(num, float):
+        return float_to_hangul(num)
+    
+    result = ""
+    str_num = str(num)[::-1]
+    
+    for i, digit in enumerate(str_num):
+        digit = int(digit)
+        if digit != 0:
+            if i == 4:
+                result = "만" + result
+            elif i > 4 and i % 4 == 0:
+                result = UNITS[4 * (i // 4)] + result
+            part = NUMBERS[digit] + UNITS[i % 4]
+            if i % 4 == 0 and digit == 1 and i != 0:
+                part = UNITS[i % 4]  # 1은 생략
+            result = part + result
+
+    if result.startswith('일'):
+        result = result[1:]
+    
+    return result
+
+def float_to_hangul(num):
+    """
+    주어진 소수를 한글로 변환합니다.
+    
+    :param num: 변환할 소수
+    :return: 한글 숫자 문자열
+    """
+    int_part, frac_part = str(num).split('.')
+    return f"{number_to_hangul(int(int_part))} 점 {''.join(NUMBERS[int(d)] for d in frac_part)}"
+
+def hangul_to_number(hangul):
+    """
+    주어진 한글 숫자 문자열을 숫자로 변환합니다.
+    
+    :param hangul: 변환할 한글 숫자 문자열
+    :return: 숫자
+    """
+    num_map = {name: value for value, name in enumerate(NUMBERS) if name}
+    unit_map = {name: 10**idx for idx, name in enumerate(UNITS) if name}
+    num = 0
+    tmp = 0
+    stack = []
+    is_float = False
+    float_part = 0
+    float_div = 1
+
+    # 소수점 분리
+    if '점' in hangul:
+        integer_part, fractional_part = hangul.split('점')
+    else:
+        integer_part, fractional_part = hangul, ''
+
+    # 정수 부분 처리
+    for char in integer_part:
+        if char in num_map:
+            stack.append(num_map[char])
+        elif char in unit_map:
+            if not stack:
+                stack.append(1)
+            tmp += sum(stack) * unit_map[char]
+            stack = []
+        else:
+            if stack:
+                tmp += sum(stack)
+            stack = []
+            num += tmp
+            tmp = 0
+
+    if stack:
+        tmp += sum(stack)
+    num += tmp
+
+    # 소수 부분 처리
+    if fractional_part:
+        for char in fractional_part:
+            if char in num_map:
+                float_part = float_part * 10 + num_map[char]
+                float_div *= 10
+        return num + float_part / float_div
+
+    return num

hangulpy-1.0.0/hangulpy/hangul_role.py

@@ -0,0 +1,21 @@
+# hangul_role.py
+
+from hangulpy.utils import CHOSUNG_LIST, JONGSUNG_LIST
+
+def can_be_chosung(char):
+    """
+    주어진 문자가 한글 초성으로 쓰일 수 있는지 확인합니다.
+    
+    :param char: 확인할 문자
+    :return: 초성으로 쓰일 수 있으면 True, 아니면 False
+    """
+    return char in CHOSUNG_LIST
+
+def can_be_jongsung(char):
+    """
+    주어진 문자가 한글 종성으로 쓰일 수 있는지 확인합니다.
+    
+    :param char: 확인할 문자
+    :return: 종성으로 쓰일 수 있으면 True, 아니면 False
+    """
+    return char in JONGSUNG_LIST

hangulpy-1.0.0/hangulpy/hangul_split.py

@@ -0,0 +1,28 @@
+# hangul_split.py
+
+from hangulpy.utils import CHOSUNG_LIST, CHOSUNG_BASE, is_hangul_char, HANGUL_BEGIN_UNICODE, JUNGSUNG_LIST, JUNGSUNG_DECOMPOSE, JONGSUNG_LIST, JONGSUNG_DECOMPOSE, JUNGSUNG_BASE
+
+def split_hangul_char(c):
+    """
+    주어진 한글 음절을 초성, 중성, 종성으로 분해하여 배열 형태로 반환합니다.
+    
+    :param c: 한글 음절 문자
+    :return: 초성, 중성, 종성을 배열 형태로 반환
+    """
+    if is_hangul_char(c):
+        # 한글 음절의 유니코드 값을 기준으로 각 성분의 인덱스를 계산합니다.
+        char_index = ord(c) - HANGUL_BEGIN_UNICODE
+        chosung_index = char_index // CHOSUNG_BASE
+        jungsung_index = (char_index % CHOSUNG_BASE) // JUNGSUNG_BASE
+        jongsung_index = char_index % JUNGSUNG_BASE
+        
+        # 중성 및 종성 분해
+        jungsung = JUNGSUNG_LIST[jungsung_index]
+        jongsung = JONGSUNG_LIST[jongsung_index]
+
+        jungsung_decomposed = JUNGSUNG_DECOMPOSE.get(jungsung, [jungsung])
+        jongsung_decomposed = JONGSUNG_DECOMPOSE.get(jongsung, [jongsung])
+        
+        return [CHOSUNG_LIST[chosung_index]] + jungsung_decomposed + jongsung_decomposed
+    
+    return [c]  # 한글이 아니면 그대로 반환

hangulpy-1.0.0/hangulpy/josa.py

@@ -0,0 +1,43 @@
+# josa.py
+
+from hangulpy.utils import is_hangul_char, HANGUL_BEGIN_UNICODE, JONGSUNG_COUNT
+
+def has_jongsung(char):
+    """
+    주어진 한글 음절에 받침이 있는지 확인합니다.
+    
+    :param char: 한글 음절 문자
+    :return: 받침이 있으면 True, 없으면 False
+    """
+    if is_hangul_char(char):
+        # 한글 음절의 유니코드 값을 기준으로 받침의 유무를 확인합니다.
+        char_index = ord(char) - HANGUL_BEGIN_UNICODE
+        return (char_index % JONGSUNG_COUNT) != 0
+    return False
+
+def josa(word, particle):
+    """
+    주어진 단어에 적절한 조사를 붙여 반환합니다.
+    
+    :param word: 조사와 결합할 단어
+    :param particle: 붙일 조사 ('을/를', '이/가', '은/는', '과/와')
+    :return: 적절한 조사가 붙은 단어 문자열
+    """
+    if not word:
+        return ''
+    
+    # 단어의 마지막 글자를 가져옵니다.
+    word_ending = word[-1]
+    # 마지막 글자의 받침 유무를 확인합니다.
+    jongsung_exists = has_jongsung(word_ending)
+    
+    if particle == '을/를':
+        return word + ('을' if jongsung_exists else '를')
+    elif particle == '이/가':
+        return word + ('이' if jongsung_exists else '가')
+    elif particle == '은/는':
+        return word + ('은' if jongsung_exists else '는')
+    elif particle == '과/와':
+        return word + ('과' if jongsung_exists else '와')
+    else:
+        raise ValueError(f"Unsupported particle: {particle}")

hangulpy-1.0.0/hangulpy/utils.py

@@ -0,0 +1,84 @@
+# utils.py
+
+# 유니코드 한글 시작과 끝
+# 유니코드에서 한글 음절은 U+AC00에서 U+D7A3까지 할당되어 있습니다.
+HANGUL_BEGIN_UNICODE = 0xAC00  # '가'의 유니코드 값
+HANGUL_END_UNICODE = 0xD7A3    # '힣'의 유니코드 값
+
+# 초성 리스트
+# 한글의 초성 19개를 정의합니다.
+CHOSUNG_LIST = [
+    'ㄱ', 'ㄲ', 'ㄴ', 'ㄷ', 'ㄸ', 'ㄹ', 'ㅁ', 'ㅂ', 'ㅃ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅉ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'
+]
+
+# 초성 인덱스 계산 상수
+# 초성, 중성, 종성의 조합으로 한글 음절을 만들 때, 초성의 위치를 계산하는 데 사용합니다.
+CHOSUNG_BASE = 588  # 초성당 588개의 음절이 있습니다. (21 * 28)
+
+# 중성 리스트
+# 한글의 중성 21개를 정의합니다.
+JUNGSUNG_LIST = [
+    'ㅏ', 'ㅐ', 'ㅑ', 'ㅒ', 'ㅓ', 'ㅔ', 'ㅕ', 'ㅖ', 'ㅗ', 'ㅘ', 'ㅙ', 'ㅚ', 'ㅛ', 'ㅜ', 'ㅝ', 'ㅞ', 'ㅟ', 'ㅠ', 'ㅡ', 'ㅢ', 'ㅣ'
+]
+
+# 복합 중성 분해 정보
+JUNGSUNG_DECOMPOSE = {
+    'ㅘ': ('ㅗ', 'ㅏ'),
+    'ㅙ': ('ㅗ', 'ㅐ'),
+    'ㅚ': ('ㅗ', 'ㅣ'),
+    'ㅝ': ('ㅜ', 'ㅓ'),
+    'ㅞ': ('ㅜ', 'ㅔ'),
+    'ㅟ': ('ㅜ', 'ㅣ'),
+    'ㅢ': ('ㅡ', 'ㅣ')
+}
+
+# 종성 리스트
+# 한글의 종성 28개를 정의합니다.
+JONGSUNG_LIST = [
+    '', 'ㄱ', 'ㄲ', 'ㄳ', 'ㄴ', 'ㄵ', 'ㄶ', 'ㄷ', 'ㄹ', 'ㄺ', 'ㄻ', 'ㄼ', 'ㄽ', 'ㄾ', 'ㄿ', 'ㅀ', 'ㅁ', 'ㅂ', 'ㅄ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'
+]
+
+# 복합 종성 분해 정보
+JONGSUNG_DECOMPOSE = {
+    'ㄳ': ('ㄱ', 'ㅅ'),
+    'ㄵ': ('ㄴ', 'ㅈ'),
+    'ㄶ': ('ㄴ', 'ㅎ'),
+    'ㄺ': ('ㄹ', 'ㄱ'),
+    'ㄻ': ('ㄹ', 'ㅁ'),
+    'ㄼ': ('ㄹ', 'ㅂ'),
+    'ㄽ': ('ㄹ', 'ㅅ'),
+    'ㄾ': ('ㄹ', 'ㅌ'),
+    'ㄿ': ('ㄹ', 'ㅍ'),
+    'ㅀ': ('ㄹ', 'ㅎ'),
+    'ㅄ': ('ㅂ', 'ㅅ')
+}
+
+# 중성 인덱스 계산 상수
+# 중성의 위치를 계산하는 데 사용합니다.
+JUNGSUNG_BASE = 28  # 중성당 28개의 음절이 있습니다.
+
+# 받침 유무를 확인하기 위한 상수
+# 한글 음절의 받침 개수는 28개입니다.
+JONGSUNG_COUNT = 28
+
+# 숫자 읽기 관련 코드
+UNITS = [
+    "", "십", "백", "천", "만", "십만", "백만", "천만", "억", "십억", "백억", "천억",
+    "조", "십조", "백조", "천조", "경", "십경", "백경", "천경", "해", "십해", "백해", "천해",
+    "자", "십자", "백자", "천자", "양", "십양", "백양", "천양", "구", "십구", "백구", "천구",
+    "간", "십간", "백간", "천간", "정", "십정", "백정", "천정", "재", "십재", "백재", "천재",
+    "극", "십극", "백극", "천극", "항하사", "십항하사", "백항하사", "천항하사", "아승기", "십아승기", "백아승기", "천아승기",
+    "나유타", "십나유타", "백나유타", "천나유타", "불가사의", "십불가사의", "백불가사의", "천불가사의", "무량대수", "십무량대수", "백무량대수", "천무량대수",
+    "겁", "십겁", "백겁", "천겁", "훈공", "십훈공", "백훈공", "천훈공"
+]
+
+NUMBERS = ["", "일", "이", "삼", "사", "오", "육", "칠", "팔", "구"]
+
+def is_hangul_char(c):
+    """
+    주어진 문자가 한글 음절인지 확인합니다.
+    
+    :param c: 확인할 문자
+    :return: 한글 음절이면 True, 아니면 False
+    """
+    return HANGUL_BEGIN_UNICODE <= ord(c) <= HANGUL_END_UNICODE

hangulpy-1.0.0/hangulpy.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: hangulpy
+Version: 1.0.0
+Summary: A Python library for processing Hangul, inspired by es-hangul.
+Home-page: https://github.com/gaon12/hangulpy
+Author: Jeong Gaon
+Author-email: gokirito12@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# hangulpy
+
+hangulpy는 한글 처리를 위한 파이썬 라이브러리입니다. es-hangul의 파이썬 버전으로, 초성 검색과 조사 붙이기 등의 기능을 제공합니다.
+
+## 설치
+
+```bash
+pip install hangulpy
+```
+
+## 사용법
+
+### 초성 검색
+
+```python
+from hangulpy import chosungIncludes
+
+searchWord = '라면'
+userInput = 'ㄹㅁ'
+
+result = chosungIncludes(searchWord, userInput)
+print(result)  # True
+```
+
+### 조사 붙이기
+
+```python
+from hangulpy import josa
+
+word1 = '사과'
+sentence1 = josa(word1, '을/를') + ' 먹었습니다.'
+print(sentence1)  # '사과를 먹었습니다.'
+
+word2 = '바나나'
+sentence2 = josa(word2, '이/가') + ' 맛있습니다.'
+print(sentence2)  # '바나나가 맛있습니다.'
+```
+
+### 자음 또는 모음 여부
+
+```python
+from hangulpy import is_hangul_consonant, is_hangul_vowel
+
+char1 = 'ㄱ'
+char2 = 'ㅏ'
+
+print(is_hangul_consonant('ㄱ'))  # True
+print(is_hangul_consonant('ㅏ'))  # False
+print(is_hangul_vowel('ㅏ'))  # True
+print(is_hangul_vowel('ㄱ'))  # False
+```
+
+### 문자열 포함 여부 확인
+
+```python
+from hangulpy import hangul_contains
+
+word = '사과'
+print(hangul_contains(word, ''))  # True
+print(hangul_contains(word, '', notallowempty=True))  # False
+print(hangul_contains(word, 'ㅅ'))  # True
+print(hangul_contains(word, '삭'))  # True
+print(hangul_contains(word, '삽'))  # False
+print(hangul_contains(word, '사과'))  # True
+
+# 문장처럼 입력 값 사이에 공백이 포함된 경우
+print(hangul_contains('사과는 맛있다', '사과는 ㅁ'))  # True
+print(hangul_contains('사과는 맛있다', '사과는 '))  # True
+```
+
+### 초/중/종성 분해(문자열 변환)
+```python
+from hangulpy import decompose_hangul_char
+
+char = '괜'
+print(decompose_hangul_char(char))  # ('ㄱ', ('ㅗ', 'ㅐ'), ('ㄴ', 'ㅈ'))
+```
+
+#### 분해 시 배열로 반환
+```python
+char1 = '값'
+print(split_hangul_char(char1))  # ['ㄱ', 'ㅏ', 'ㅂ', 'ㅅ']
+
+char2 = 'ㅘ'
+print(split_hangul_char(char2))  # ['ㅗ', 'ㅏ']
+
+char3 = 'ㄵ'
+print(split_hangul_char(char3))  # ['ㄴ', 'ㅈ']
+```
+
+### 자음으로 끝나는지 확인
+```python
+from hangulpy import ends_with_consonant
+
+print(ends_with_consonant('강'))  # False
+print(ends_with_consonant('각'))  # True
+print(ends_with_consonant('ㄱ'))  # True
+print(ends_with_consonant('ㅏ'))  # False
+print(ends_with_consonant('a'))  # False
+print(ends_with_consonant('한'))  # True
+print(ends_with_consonant('하'))  # False
+```
+
+### 초성 또는 종성으로 쓰일 수 있는지 확인
+```python
+from hangulpy import can_be_chosung, can_be_jongsung
+
+print(can_be_chosung('ㄱ'))  # True
+print(can_be_chosung('ㄳ'))  # False
+print(can_be_chosung('ㄸ'))  # True
+print(can_be_jongsung('ㄲ'))  # True
+print(can_be_jongsung('ㄸ'))  # False
+print(can_be_jongsung('ㄳ'))  # True
+```
+
+### 숫자 읽기
+```python
+from hangulpy import number_to_hangul, hangul_to_number
+
+print(number_to_hangul(1234))  # 천이백삼십사
+print(number_to_hangul(3.1415926))  # 삼 점 일사일오구이육
+print(hangul_to_number("천이백삼십사"))  # 1234
+print(hangul_to_number("삼점일사일오구이육"))  # 3.1415926
+```

hangulpy-1.0.0/hangulpy.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+hangulpy/__init__.py
+hangulpy/chosung.py
+hangulpy/hangul_check.py
+hangulpy/hangul_contains.py
+hangulpy/hangul_decompose.py
+hangulpy/hangul_ends_with_consonant.py
+hangulpy/hangul_number.py
+hangulpy/hangul_role.py
+hangulpy/hangul_split.py
+hangulpy/josa.py
+hangulpy/utils.py
+hangulpy.egg-info/PKG-INFO
+hangulpy.egg-info/SOURCES.txt
+hangulpy.egg-info/dependency_links.txt
+hangulpy.egg-info/top_level.txt

hangulpy-1.0.0/hangulpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hangulpy-1.0.0/hangulpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+hangulpy

hangulpy-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hangulpy-1.0.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='hangulpy',
+    version='1.0.0',
+    description='A Python library for processing Hangul, inspired by es-hangul.',
+    long_description=open('README.md', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/gaon12/hangulpy',
+    author='Jeong Gaon',
+    author_email='gokirito12@gmail.com',
+    license='MIT',
+    packages=find_packages(),
+    install_requires=[],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.8',
+)