hython-lang 2.0.0__py3-none-any.whl

hython/runtime_manager.py

@@ -0,0 +1,83 @@
+"""Adapter for the official Windows Python install manager."""
+from __future__ import annotations
+import os
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from .environment import external_source_root
+
+class RuntimeManagerError(RuntimeError):
+    pass
+
+def find_manager() -> str:
+    manager = shutil.which("pymanager")
+    if manager:
+        return manager
+    py = shutil.which("py")
+    if py:
+        probe = subprocess.run([py, "help", "install"], capture_output=True, text=True, timeout=10)
+        if probe.returncode == 0:
+            return py
+    raise RuntimeManagerError("공식 Python install manager가 없습니다. Microsoft Store에서 설치하거나 `winget install 9NQ7512CXL7T`를 실행하세요.")
+
+def _command(*args: str, capture: bool = False):
+    return subprocess.run([find_manager(), *args], check=True, text=True, capture_output=capture)
+
+def list_runtimes(*, online: bool = False, tag: str | None = None) -> str:
+    args = ["list"]
+    if online:
+        args.append("--online")
+    if tag:
+        args.extend(["--one", tag])
+    return _command(*args, capture=True).stdout
+
+def install_runtime(tag: str = "default", *, update: bool = False, dry_run: bool = False) -> None:
+    args = ["install"]
+    if update:
+        args.append("--update")
+    if dry_run:
+        args.append("--dry-run")
+    _command(*args, tag)
+
+def set_preference(root: Path, tag: str) -> Path:
+    if not tag or any(c.isspace() for c in tag):
+        raise ValueError("런타임 태그는 비어 있거나 공백을 포함할 수 없습니다.")
+    output = root / ".hython-runtime"
+    output.write_text(tag + "\n", encoding="utf-8")
+    return output
+
+def get_preference(start: Path) -> str | None:
+    current = start.resolve()
+    if current.is_file():
+        current = current.parent
+    for directory in (current, *current.parents):
+        candidate = directory / ".hython-runtime"
+        if candidate.is_file():
+            return candidate.read_text(encoding="utf-8").strip() or None
+    try:
+        home=Path(os.environ.get("HYTHON_HOME",Path.home()/".hython"))
+        payload=json.loads((home/"state.json").read_text(encoding="utf-8"))
+        tag=payload.get("runtime_tag")
+        return tag if isinstance(tag,str) and tag else None
+    except (OSError,UnicodeError,json.JSONDecodeError):
+        return None
+
+def run_hython_with_runtime(tag: str, argv: list[str]) -> int:
+    """Run this installed Hython package inside a managed Python runtime."""
+    env=os.environ.copy()
+    env["HYTHON_RUNTIME_ACTIVE"]=tag
+    source_root=str(external_source_root())
+    env["PYTHONPATH"]=source_root+os.pathsep+env.get("PYTHONPATH","")
+    return subprocess.run([find_manager(),"exec",f"-V:{tag}","-m","hython",*argv],env=env).returncode
+
+def reexec_with_preferred_runtime(argv: list[str], start: Path) -> None:
+    tag = get_preference(start)
+    if not tag or os.environ.get("HYTHON_RUNTIME_ACTIVE") == tag:
+        return
+    env = os.environ.copy()
+    env["HYTHON_RUNTIME_ACTIVE"] = tag
+    source_root = str(external_source_root())
+    env["PYTHONPATH"] = source_root + os.pathsep + env.get("PYTHONPATH", "")
+    result = subprocess.run([find_manager(), "exec", f"-V:{tag}", "-m", "hython", *argv], env=env)
+    raise SystemExit(result.returncode)

hython/translator.py

@@ -0,0 +1,244 @@
+"""Token-safe translation between Hython and Python."""
+
+from __future__ import annotations
+
+import io
+import re
+import tokenize
+from dataclasses import dataclass
+from collections.abc import Mapping
+
+from .phonetics import pronounce_identifier
+from .vocabulary import (
+    BUILTINS, KEYWORDS, LIBRARY_NAMES, SPECIAL_NAMES,
+    HYTHON_TO_PYTHON, PYTHON_TO_HYTHON,
+)
+
+LITERAL_PREFIXES = {
+    "에프": "f", "알": "r", "비": "b", "유": "u",
+    "알에프": "rf", "에프알": "fr", "비알": "br", "알비": "rb",
+}
+PYTHON_LITERAL_PREFIXES = {
+    python: hython for hython, python in LITERAL_PREFIXES.items()
+}
+
+
+def normalize_literal_prefixes(source: str) -> str:
+    """Turn adjacent Hangul string prefixes into Python lexical prefixes."""
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except (tokenize.TokenError, IndentationError) as exc:
+        raise TranslationError(str(exc)) from exc
+    lines = source.splitlines(keepends=True)
+    offsets: list[int] = []
+    total = 0
+    for line in lines:
+        offsets.append(total)
+        total += len(line)
+    replacements: list[tuple[int, int, str]] = []
+    for index, token in enumerate(tokens[:-1]):
+        following = tokens[index + 1]
+        if (
+            token.type == tokenize.NAME
+            and token.string in LITERAL_PREFIXES
+            and following.type == tokenize.STRING
+            and token.end == following.start
+        ):
+            start = offsets[token.start[0] - 1] + token.start[1]
+            end = offsets[token.end[0] - 1] + token.end[1]
+            replacements.append((start, end, LITERAL_PREFIXES[token.string]))
+    for start, end, replacement in reversed(replacements):
+        source = source[:start] + replacement + source[end:]
+    return source
+
+
+def _hython_names() -> dict[str, str]:
+    # Lazy import keeps startup cheap and allows newly generated dictionaries to
+    # become active without restarting a long-running process.
+    from .package_manager import load_dictionaries
+    from .runtime import load_runtime_spellings
+    # Core syntax wins if an untrusted/generated package dictionary collides.
+    return load_dictionaries() | load_runtime_spellings() | HYTHON_TO_PYTHON
+
+
+def _python_names() -> dict[str, str]:
+    from .package_manager import load_python_dictionaries
+    from .runtime import load_runtime_spellings
+    runtime = {python: spoken for spoken, python in load_runtime_spellings().items()}
+    return load_python_dictionaries() | runtime | PYTHON_TO_HYTHON
+
+
+class TranslationError(SyntaxError):
+    """Raised when a source stream cannot be tokenized."""
+
+
+@dataclass(frozen=True)
+class EnglishName:
+    """One executable English identifier left in Hython source."""
+
+    name: str
+    line: int
+    column: int
+    suggestion: str
+
+
+def _translate(source: str, names: Mapping[str, str], *, preserve_aliases: bool = False) -> str:
+    source = normalize_literal_prefixes(source)
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except (tokenize.TokenError, IndentationError) as exc:
+        raise TranslationError(str(exc)) from exc
+
+    aliases = {
+        tokens[index + 1].string
+        for index, token in enumerate(tokens[:-1])
+        if preserve_aliases and token.type == tokenize.NAME
+        and token.string in ("as", "애즈")
+        and tokens[index + 1].type == tokenize.NAME
+    }
+    changed = []
+    for index, token in enumerate(tokens):
+        # A Korean import alias is user-owned, but an identically spelled API
+        # member after a dot still needs translation (티케이.티케이 -> 티케이.Tk).
+        alias_reference = token.string in aliases and (
+            index == 0 or tokens[index - 1].string != "."
+        )
+        changed.append(
+            token._replace(string=names.get(token.string, token.string))
+            if token.type == tokenize.NAME and not alias_reference
+            else token
+        )
+    return tokenize.untokenize(changed)
+
+
+def to_python(source: str) -> str:
+    """Translate Hython source to executable Python without touching text/comments."""
+    return _translate(source, _hython_names(), preserve_aliases=True)
+
+
+def to_hython(source: str) -> str:
+    """Translate supported Python names to canonical Hython spellings."""
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except (tokenize.TokenError, IndentationError) as exc:
+        raise TranslationError(str(exc)) from exc
+    from .runtime import load_runtime_spellings
+    runtime = {
+        python: spoken for spoken, python in load_runtime_spellings().items()
+    }
+    core = KEYWORDS | BUILTINS | SPECIAL_NAMES | runtime
+    api = _python_names() | LIBRARY_NAMES
+    imported: set[str] = set()
+    in_import = False
+    after_as = False
+    import_contexts: list[bool] = []
+    for token in tokens:
+        if token.type in (tokenize.NEWLINE, tokenize.NL):
+            in_import = False
+            after_as = False
+        elif token.type == tokenize.NAME:
+            if token.string in ("import", "from"):
+                in_import = True
+            elif in_import and token.string == "as":
+                after_as = True
+            elif in_import and not after_as:
+                imported.add(token.string)
+            elif after_as:
+                after_as = False
+        import_contexts.append(in_import)
+    changed = []
+    for index, token in enumerate(tokens):
+        previous = tokens[index - 1].string if index else ""
+        import_context = import_contexts[index]
+        if token.type == tokenize.NAME:
+            if token.string in core:
+                token = token._replace(string=core[token.string])
+            elif (
+                token.string in api
+                and (previous == "." or import_context or token.string in imported)
+            ):
+                token = token._replace(string=api[token.string])
+        changed.append(token)
+    return tokenize.untokenize(changed)
+
+
+def audit_english(source: str) -> list[EnglishName]:
+    """Find ASCII identifiers in code while ignoring strings and comments."""
+    known = _python_names()
+    try:
+        tokens = tokenize.generate_tokens(io.StringIO(source).readline)
+        result = [
+            EnglishName(
+                token.string,
+                token.start[0],
+                token.start[1] + 1,
+                known.get(token.string, pronounce_identifier(token.string)),
+            )
+            for token in tokens
+            if token.type == tokenize.NAME
+            and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", token.string)
+        ]
+        for token in tokenize.generate_tokens(io.StringIO(source).readline):
+            prefix = ""
+            if token.type == tokenize.STRING:
+                match = re.match(r"(?i)(rf|fr|rb|br|r|f|b|u)(?=['\"])", token.string)
+                prefix = match.group(1).lower() if match else ""
+            elif token.type == getattr(tokenize, "FSTRING_START", -1):
+                prefix = token.string[:-1].lower()
+            if prefix in PYTHON_LITERAL_PREFIXES:
+                result.append(EnglishName(
+                    prefix, token.start[0], token.start[1] + 1,
+                    PYTHON_LITERAL_PREFIXES[prefix],
+                ))
+        return result
+    except (tokenize.TokenError, IndentationError) as exc:
+        raise TranslationError(str(exc)) from exc
+
+
+def koreanize(source: str) -> str:
+    """Convert every ASCII code identifier to a deterministic Hangul spelling.
+
+    Known Python/package API names use their registered spelling. Unknown names
+    are treated as user identifiers, so renaming all their occurrences is safe.
+    """
+    known = _python_names()
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except (tokenize.TokenError, IndentationError) as exc:
+        raise TranslationError(str(exc)) from exc
+    reverse_names = _hython_names()
+    generated: dict[str, str] = {}
+    occupied = set(reverse_names)
+    changed = []
+    for token in tokens:
+        if token.type == tokenize.NAME and re.fullmatch(
+            r"[A-Za-z_][A-Za-z0-9_]*", token.string
+        ):
+            spoken = known.get(token.string)
+            if spoken is None:
+                spoken = generated.get(token.string)
+                if spoken is None:
+                    base = pronounce_identifier(token.string)
+                    spoken = base
+                    suffix = 2
+                    while spoken in occupied:
+                        spoken = f"{base}{suffix}"
+                        suffix += 1
+                    generated[token.string] = spoken
+                    occupied.add(spoken)
+            token = token._replace(string=spoken)
+        elif token.type in (tokenize.STRING, getattr(tokenize, "FSTRING_START", -1)):
+            match = re.match(r"(?i)(rf|fr|rb|br|r|f|b|u)(?=['\"])", token.string)
+            if match and match.group(1).lower() in PYTHON_LITERAL_PREFIXES:
+                prefix = match.group(1)
+                token = token._replace(
+                    string=PYTHON_LITERAL_PREFIXES[prefix.lower()]
+                    + token.string[len(prefix):]
+                )
+        changed.append(token)
+    return tokenize.untokenize(changed)
+
+
+def compile_hython(source: str, filename: str = "<하이썬>", mode: str = "exec"):
+    """Translate and compile Hython source."""
+    return compile(to_python(source), filename, mode)

hython/updater.py

@@ -0,0 +1,93 @@
+"""Lifecycle for generated syntax state kept outside the installed core."""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import tempfile
+from pathlib import Path
+
+from . import __version__
+from .package_manager import refresh_dictionaries
+from .runtime import sync_runtime
+
+
+def state_root() -> Path:
+    root = Path(os.environ.get("HYTHON_HOME", Path.home() / ".hython"))
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def marker_path() -> Path:
+    return state_root() / "state.json"
+
+
+def is_initialized() -> bool:
+    try:
+        payload = json.loads(marker_path().read_text(encoding="utf-8"))
+        return (
+            payload.get("format") == 1
+            and payload.get("hython_version") == __version__
+            and payload.get("python_version") == platform.python_version()
+        )
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return False
+
+
+def initialize(*, force: bool = False) -> dict:
+    if is_initialized() and not force:
+        return {"initialized": False, "runtime": None}
+    previous = {}
+    try:
+        previous=json.loads(marker_path().read_text(encoding="utf-8"))
+    except (OSError,UnicodeError,json.JSONDecodeError):
+        pass
+    runtime = sync_runtime()
+    if previous:
+        refresh_dictionaries()
+    payload = {
+        "format": 1,
+        "hython_version": __version__,
+        "python_version": platform.python_version(),
+    }
+    if isinstance(previous.get("runtime_tag"),str):
+        payload["runtime_tag"]=previous["runtime_tag"]
+    _atomic_json(marker_path(), payload)
+    return {"initialized": True, "runtime": runtime}
+
+
+def refresh(*, runtime_tag: str | None = None) -> dict:
+    """Regenerate active runtime and package overlays, pruning stale packages."""
+    runtime = sync_runtime()
+    refreshed, removed = refresh_dictionaries()
+    payload = {
+        "format": 1,
+        "hython_version": __version__,
+        "python_version": platform.python_version(),
+    }
+    if runtime_tag:
+        payload["runtime_tag"] = runtime_tag
+    else:
+        try:
+            previous=json.loads(marker_path().read_text(encoding="utf-8"))
+            if isinstance(previous.get("runtime_tag"),str):
+                payload["runtime_tag"]=previous["runtime_tag"]
+        except (OSError,UnicodeError,json.JSONDecodeError):
+            pass
+    _atomic_json(marker_path(), payload)
+    return {"runtime": runtime, "refreshed": refreshed, "removed": removed}
+
+
+def _atomic_json(output: Path, payload: dict) -> None:
+    handle, temporary = tempfile.mkstemp(prefix=output.name + ".", suffix=".tmp", dir=output.parent)
+    try:
+        with os.fdopen(handle, "w", encoding="utf-8", newline="\n") as stream:
+            json.dump(payload, stream, ensure_ascii=False, indent=2)
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        Path(temporary).replace(output)
+    except BaseException:
+        Path(temporary).unlink(missing_ok=True)
+        raise