PyUMSN 1.0.0__py3-none-any.whl

pyumsn/__init__.py

@@ -0,0 +1,35 @@
+"""PyUMSN — 엄슨(UMSN) 프로그래밍 언어.
+
+    >>> import pyumsn
+    >>> pyumsn.umsn_to_py('엄!..하"안녕 엄슨"..다')
+    'print("안녕 엄슨")'
+    >>> pyumsn.py_to_umsn('print("안녕 엄슨")')
+    '엄!..하"안녕 엄슨"..다'
+"""
+
+__version__ = "1.0.0"
+
+from .errors import UmsnEncodingError, UmsnError, UmsnSyntaxError  # noqa: E402
+from .sourceio import read_source, write_source  # noqa: E402
+from .translator import (check_umsn, highlight_spans, py_to_umsn,  # noqa: E402
+                         tokenize_umsn, transliterate, umsn_to_py, untransliterate)
+from .vocab import all_words, category_of  # noqa: E402
+
+__all__ = [
+    "__version__", "UmsnError", "UmsnSyntaxError", "UmsnEncodingError",
+    "umsn_to_py", "py_to_umsn", "check_umsn", "highlight_spans", "tokenize_umsn",
+    "transliterate", "untransliterate", "read_source", "write_source",
+    "all_words", "category_of", "run_file", "install_import_hook",
+]
+
+
+def run_file(path, args=(), keep=False):
+    """엄슨 파일을 실행하고 종료 코드를 돌려준다."""
+    from .runner import run_file as _run
+    return _run(path, list(args), keep=keep)
+
+
+def install_import_hook():
+    """``import`` 로 ``.umsn`` 모듈을 불러올 수 있게 한다."""
+    from .importer import install
+    install()

pyumsn/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

pyumsn/cli.py

@@ -0,0 +1,258 @@
+"""``pyumsn`` 명령줄 도구."""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from . import __version__, vocab
+from .errors import UmsnEncodingError, UmsnError, UmsnSyntaxError
+from .sourceio import read_source, write_source
+from .translator import check_umsn, py_to_umsn, transliterate, umsn_to_py, untransliterate
+
+IDE_PATH = Path(__file__).resolve().parent / "ide" / "umsn_ide.umsn"
+
+
+def _setup_stdio():
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except (AttributeError, ValueError, OSError):
+            pass
+
+
+def _say(text, err=False):
+    stream = sys.stderr if err else sys.stdout
+    stream.write(text + "\n")
+    stream.flush()
+
+
+# ---------------------------------------------------------------------------
+# 변환 (topy / toumsn)
+# ---------------------------------------------------------------------------
+def _convert_one(src_path, out_path, direction, keep_symbols):
+    text = read_source(src_path)
+    if direction == "topy":
+        result = umsn_to_py(text, filename=str(src_path))
+    else:
+        result = py_to_umsn(text, filename=str(src_path), keep_symbols=keep_symbols)
+    if out_path == "-":
+        sys.stdout.write(result)
+        sys.stdout.flush()
+        return
+    out_path = Path(out_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    write_source(out_path, result)
+    _say("만들었슨: %s → %s" % (src_path, out_path), err=True)
+
+
+def _convert(args, direction):
+    src_suffix, dst_suffix = (".umsn", ".py") if direction == "topy" else (".py", ".umsn")
+    source = Path(args.source)
+    if not source.exists():
+        _say("엄슨 오류! 파일이나 폴더가 없슨: %s" % source, err=True)
+        return 1
+    keep = getattr(args, "keep_symbols", False)
+    failed = 0
+    if source.is_dir():
+        if args.output == "-":
+            _say("엄슨 오류! 폴더는 표준 출력(-)으로 변환할 수 없슨.", err=True)
+            return 1
+        out_root = Path(args.output) if args.output else source
+        files = sorted(p for p in source.rglob("*" + src_suffix) if p.is_file())
+        if not files:
+            _say("변환할 %s 파일이 없슨: %s" % (src_suffix, source), err=True)
+        for path in files:
+            target = out_root / path.relative_to(source).with_suffix(dst_suffix)
+            try:
+                _convert_one(path, target, direction, keep)
+            except UmsnError as exc:
+                failed += 1
+                _report_error(exc)
+        return 1 if failed else 0
+    out = args.output or str(source.with_suffix(dst_suffix))
+    try:
+        _convert_one(source, out, direction, keep)
+    except UmsnError as exc:
+        _report_error(exc)
+        return 1
+    return 0
+
+
+def _report_error(exc):
+    if isinstance(exc, UmsnSyntaxError):
+        _say(exc.report(), err=True)
+    else:
+        _say("엄슨 오류! %s" % exc, err=True)
+
+
+# ---------------------------------------------------------------------------
+# 명령
+# ---------------------------------------------------------------------------
+def cmd_run(args):
+    from .runner import run_file
+    try:
+        return run_file(args.file, args.args, keep=args.keep, show_py=args.show_py)
+    except FileNotFoundError:
+        _say("엄슨 오류! 파일이 없슨: %s" % args.file, err=True)
+        return 1
+    except UmsnError as exc:
+        _report_error(exc)
+        return 1
+
+
+def cmd_topy(args):
+    return _convert(args, "topy")
+
+
+def cmd_toumsn(args):
+    return _convert(args, "toumsn")
+
+
+def cmd_check(args):
+    bad = 0
+    for name in args.files:
+        try:
+            source = read_source(name)
+        except (OSError, UmsnEncodingError) as exc:
+            _say("엄슨 오류! %s" % exc, err=True)
+            bad += 1
+            continue
+        problems = check_umsn(source)
+        if problems:
+            bad += 1
+            _say(UmsnSyntaxError(problems, filename=name, source=source).report(), err=True)
+        else:
+            _say("문제 없슨! %s" % name)
+    return 1 if bad else 0
+
+
+def cmd_ide(args):
+    from .runner import run_file
+    extra = [os.path.abspath(args.file)] if args.file else []
+    try:
+        return run_file(IDE_PATH, extra)
+    except UmsnError as exc:
+        _report_error(exc)
+        return 1
+
+
+def cmd_repl(args):
+    from .repl import main
+    return main()
+
+
+def _markdown_table():
+    lines = ["# 엄슨(UMSN) 단어장", "",
+             "`pyumsn words --markdown` 으로 자동 생성한 문서입니다.", ""]
+    groups = [("예약어", vocab.KEYWORDS), ("내장 함수·상수·예외", vocab.BUILTINS),
+              ("관례·특수 이름", vocab.SPECIAL_NAMES), ("메소드·자주 쓰는 인자", vocab.METHODS)]
+    groups += [("라이브러리 — " + title, table) for title, table in vocab.LIBRARY_GROUPS.items()]
+    for title, table in groups:
+        lines += ["## " + title, "", "| 엄슨 | 파이썬 |", "|---|---|"]
+        lines += ["| `%s` | `%s` |" % (um, py) for py, um in table.items()]
+        lines.append("")
+    lines += ["## 기호 (문장부호·연산자)", "", "| 엄슨 | 파이썬 |", "|---|---|"]
+    lines += ["| `%s` | `%s` |" % (um, py.replace("|", "\\|")) for py, um in vocab.SYMBOL2UMSN.items()]
+    lines += ["", "`.` (속성 접근)과 `...` 은 그대로 씁니다.", ""]
+    lines += ["## 문자열 접두사", "", "| 엄슨 | 파이썬 |", "|---|---|"]
+    lines += ["| `%s\"...\"` | `%s\"...\"` |" % (um, py) for py, um in vocab.STRING_PREFIX_CHARS.items()]
+    lines += ["", "대문자 접두사는 앞에 `대` 를 붙입니다 (`대형\"...\"` = `F\"...\"`). 조합 가능: `형날`=`fr`, `날바`=`rb`.", ""]
+    lines += ["## 음역 (사전에 없는 영어 이름)", "",
+              "표지 `%s` 뒤에 알파벳을 한 글자씩 한글 음절로 적습니다. 대문자는 앞에 `대`, 숫자와 `_` 는 그대로."
+              % vocab.TRANSLIT_MARK, "", "| 알파벳 | 한글 |", "|---|---|"]
+    lines += ["| `%s` | `%s` |" % (a, h) for a, h in vocab.TRANSLIT_LETTERS.items()]
+    lines += ["", "예: `polyfit` → `%s`, `DataFrame` 이 사전에 없다면 `%s`" %
+              (transliterate("polyfit"), transliterate("DataFrame")), ""]
+    return "\n".join(lines)
+
+
+def cmd_words(args):
+    if args.translit:
+        for name in args.translit:
+            if name in vocab.PY2UMSN:
+                _say("%s → %s  (사전 단어)" % (name, vocab.PY2UMSN[name]))
+            else:
+                try:
+                    _say("%s → %s" % (name, transliterate(name)))
+                except ValueError as exc:
+                    _say("엄슨 오류! %s" % exc, err=True)
+                    return 1
+        return 0
+    if args.untranslit:
+        for word in args.untranslit:
+            py = vocab.UMSN2PY.get(word) or vocab.UMSN2SYMBOL.get(word) or untransliterate(word)
+            _say("%s → %s" % (word, py if py else "(엄슨 단어/음역이 아닙니다)"))
+        return 0
+    if args.markdown:
+        sys.stdout.write(_markdown_table())
+        return 0
+    query = (args.search or "").lower()
+    for title, um, py in vocab.all_words():
+        if query and query not in um.lower() and query not in py.lower() and query not in title.lower():
+            continue
+        _say("%-18s %-22s %s" % (um, py, title))
+    return 0
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="pyumsn",
+        description="엄슨(UMSN) 프로그래밍 언어 도구 — 엄슨 ↔ 파이썬 변환, 실행, IDE",
+        epilog="예) pyumsn run 안녕.umsn  |  pyumsn topy 안녕.umsn  |  pyumsn toumsn hello.py  |  pyumsn ide")
+    parser.add_argument("--version", "-V", action="version", version="PyUMSN %s" % __version__)
+    sub = parser.add_subparsers(dest="command", metavar="명령")
+
+    p = sub.add_parser("run", help="엄슨 파일 실행 (임시 파이썬 파일을 만들어 실행)")
+    p.add_argument("file", help=".umsn 파일")
+    p.add_argument("args", nargs=argparse.REMAINDER, help="프로그램에 넘길 인자")
+    p.add_argument("--keep", action="store_true", help="임시 파이썬 파일을 지우지 않음")
+    p.add_argument("--show-py", action="store_true", help="변환된 파이썬 코드를 먼저 보여줌")
+    p.set_defaults(func=cmd_run)
+
+    p = sub.add_parser("topy", help="엄슨 → 파이썬 변환 (파일 또는 폴더)")
+    p.add_argument("source", help=".umsn 파일 또는 폴더")
+    p.add_argument("-o", "--output", help="출력 파일/폴더 ('-' 는 화면)")
+    p.set_defaults(func=cmd_topy)
+
+    p = sub.add_parser("toumsn", help="파이썬 → 엄슨 변환 (파일 또는 폴더)")
+    p.add_argument("source", help=".py 파일 또는 폴더")
+    p.add_argument("-o", "--output", help="출력 파일/폴더 ('-' 는 화면)")
+    p.add_argument("--keep-symbols", action="store_true", help="괄호·연산자 기호는 ASCII 그대로 둠")
+    p.set_defaults(func=cmd_toumsn)
+
+    p = sub.add_parser("check", help="엄슨 파일 검사 (영어 이름 등)")
+    p.add_argument("files", nargs="+", help=".umsn 파일")
+    p.set_defaults(func=cmd_check)
+
+    p = sub.add_parser("ide", help="UMSN-IDE 실행")
+    p.add_argument("file", nargs="?", help="열 파일")
+    p.set_defaults(func=cmd_ide)
+
+    p = sub.add_parser("repl", help="엄슨 대화형 셸")
+    p.set_defaults(func=cmd_repl)
+
+    p = sub.add_parser("words", help="엄슨 단어장 보기 / 음역")
+    p.add_argument("--search", "-s", help="찾을 말 (엄슨 또는 파이썬)")
+    p.add_argument("--markdown", action="store_true", help="마크다운 표로 출력")
+    p.add_argument("--translit", nargs="+", metavar="영어이름", help="영어 이름 → 엄슨 음역")
+    p.add_argument("--untranslit", nargs="+", metavar="엄슨단어", help="엄슨 단어/음역 → 파이썬")
+    p.set_defaults(func=cmd_words)
+    return parser
+
+
+def main(argv=None):
+    _setup_stdio()
+    argv = sys.argv[1:] if argv is None else list(argv)
+    if argv and argv[0].lower().endswith(".umsn"):
+        argv = ["run"] + argv
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyumsn/errors.py

@@ -0,0 +1,75 @@
+"""엄슨 오류 클래스."""
+
+
+class UmsnError(Exception):
+    """PyUMSN 의 모든 오류의 부모."""
+
+
+class UmsnEncodingError(UmsnError):
+    """UTF-8 이 아닌 소스 파일."""
+
+
+class UmsnSyntaxError(UmsnError):
+    """엄슨 문법 오류 (영어 이름, 알 수 없는 기호어, 닫히지 않은 문자열 등).
+
+    ``problems`` 에는 ``(줄번호, 칸번호, 길이, 메시지)`` 목록이 들어 있고,
+    대표 오류는 그중 첫 번째이다. 줄번호는 1부터, 칸번호는 0부터 센다.
+    """
+
+    def __init__(self, problems, filename=None, source=None, incomplete=False):
+        if isinstance(problems, str):
+            problems = [(None, None, 0, problems)]
+        self.problems = list(problems)
+        self.filename = filename
+        self.source = source
+        self.incomplete = incomplete
+        first = self.problems[0]
+        self.lineno, self.col, self.length, self.msg = first
+        super().__init__(self._format())
+
+    def line_text(self, lineno):
+        if self.source is None or lineno is None:
+            return None
+        lines = self.source.splitlines()
+        if 1 <= lineno <= len(lines):
+            return lines[lineno - 1]
+        return None
+
+    def _where(self, lineno, col):
+        parts = []
+        if self.filename:
+            parts.append(str(self.filename))
+        if lineno is not None:
+            parts.append("%d줄 %d칸" % (lineno, (col or 0) + 1))
+        return " ".join(parts)
+
+    def _format(self):
+        where = self._where(self.lineno, self.col)
+        text = "엄슨 문법 오류"
+        if where:
+            text += " (%s)" % where
+        text += ": " + self.msg
+        if len(self.problems) > 1:
+            text += " (외 %d개)" % (len(self.problems) - 1)
+        return text
+
+    def report(self):
+        """모든 문제를 사람이 읽기 좋게 여러 줄로 만든다."""
+        out = []
+        for lineno, col, length, msg in self.problems:
+            where = self._where(lineno, col)
+            out.append("엄슨 문법 오류%s: %s" % (" (%s)" % where if where else "", msg))
+            line = self.line_text(lineno)
+            if line is not None:
+                col = col or 0
+                out.append("    " + line.replace("\t", "    "))
+                pad = _display_width(line[:col].replace("\t", "    "))
+                mark = max(1, _display_width(line[col:col + (length or 1)]))
+                out.append("    " + " " * pad + "^" * mark)
+        return "\n".join(out)
+
+
+def _display_width(text):
+    """터미널 표시 폭 (한글 등 전각 문자는 2칸)."""
+    import unicodedata
+    return sum(2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 for ch in text)