hython-lang 2.0.0__py3-none-any.whl

hython/compiler_manager.py

@@ -0,0 +1,227 @@
+"""Verified, side-by-side Hython compiler updates.
+
+The installed bootstrap package is never overwritten.  A verified wheel is
+expanded below HYTHON_HOME and selected by re-executing Hython with that tree
+at the front of PYTHONPATH.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+from . import __version__
+from .environment import external_source_root, is_frozen
+
+PYPI_URL = "https://pypi.org/pypi/hython-lang/json"
+
+
+class CompilerUpdateError(RuntimeError):
+    pass
+
+
+def compiler_root() -> Path:
+    root=Path(os.environ.get("HYTHON_HOME",Path.home()/".hython"))/"compilers"
+    root.mkdir(parents=True,exist_ok=True)
+    return root
+
+
+def state_path() -> Path:
+    return compiler_root()/"state.json"
+
+
+def load_state() -> dict:
+    try:
+        payload=json.loads(state_path().read_text(encoding="utf-8"))
+        if payload.get("format") != 1:
+            return {"format":1,"active":None,"history":[]}
+        return payload
+    except (OSError,UnicodeError,json.JSONDecodeError):
+        return {"format":1,"active":None,"history":[]}
+
+
+def active_version() -> str | None:
+    value=load_state().get("active")
+    return value if isinstance(value,str) and (compiler_root()/value).is_dir() else None
+
+
+def _version_key(value: str) -> tuple:
+    match=re.match(r"^(\d+)\.(\d+)\.(\d+)(?:(?:[.-]?dev)(\d+))?",value)
+    if not match:
+        return (-1,value)
+    major,minor,patch,dev=match.groups()
+    return (int(major),int(minor),int(patch),1 if dev is None else 0,int(dev or 0))
+
+
+def query_latest(*, url: str = PYPI_URL, timeout: int = 20) -> dict:
+    if not url.lower().startswith("https://"):
+        raise CompilerUpdateError("컴파일러 인덱스는 HTTPS 주소여야 합니다.")
+    request=urllib.request.Request(url,headers={"User-Agent":f"hython/{__version__}"})
+    try:
+        with urllib.request.urlopen(request,timeout=timeout) as response:
+            payload=json.load(response)
+    except (OSError,ValueError) as exc:
+        raise CompilerUpdateError(f"컴파일러 인덱스 조회 실패: {exc}") from exc
+    version=payload.get("info",{}).get("version")
+    files=payload.get("releases",{}).get(version,[]) if isinstance(version,str) else []
+    candidates=[item for item in files if isinstance(item,dict) and item.get("packagetype")=="bdist_wheel"]
+    universal=[item for item in candidates if str(item.get("filename","")).endswith("py3-none-any.whl")]
+    candidates=universal or candidates
+    if not version or not candidates:
+        raise CompilerUpdateError("설치 가능한 공식 Hython compiler wheel이 없습니다.")
+    item=candidates[0]
+    digest=item.get("digests",{}).get("sha256")
+    artifact_url=item.get("url")
+    if not isinstance(digest,str) or len(digest)!=64 or not isinstance(artifact_url,str) or not artifact_url.startswith("https://"):
+        raise CompilerUpdateError("PyPI wheel의 SHA-256 메타데이터가 올바르지 않습니다.")
+    return {"version":version,"url":artifact_url,"sha256":digest,"filename":item.get("filename")}
+
+
+def check() -> dict:
+    latest=query_latest()
+    current=active_version() or __version__
+    latest["current"]=current
+    latest["update_available"]=_version_key(latest["version"])>_version_key(current)
+    return latest
+
+
+def _download(url: str, destination: Path, *, timeout: int = 60) -> None:
+    request=urllib.request.Request(url,headers={"User-Agent":f"hython/{__version__}"})
+    try:
+        with urllib.request.urlopen(request,timeout=timeout) as response, destination.open("wb") as output:
+            shutil.copyfileobj(response,output)
+    except OSError as exc:
+        raise CompilerUpdateError(f"compiler wheel 다운로드 실패: {exc}") from exc
+
+
+def _safe_extract(wheel: Path, destination: Path) -> None:
+    try:
+        with zipfile.ZipFile(wheel) as archive:
+            root=destination.resolve()
+            for member in archive.infolist():
+                target=(destination/member.filename).resolve()
+                if target!=root and root not in target.parents:
+                    raise CompilerUpdateError("wheel에 안전하지 않은 경로가 포함되어 있습니다.")
+                if member.is_dir():
+                    target.mkdir(parents=True,exist_ok=True)
+                else:
+                    target.parent.mkdir(parents=True,exist_ok=True)
+                    with archive.open(member) as source,target.open("wb") as output:
+                        shutil.copyfileobj(source,output)
+    except (OSError,zipfile.BadZipFile) as exc:
+        raise CompilerUpdateError(f"compiler wheel 압축 해제 실패: {exc}") from exc
+
+
+def _smoke_test(path: Path, version: str) -> None:
+    env=os.environ.copy()
+    env["PYTHONPATH"]=str(path)
+    env["HYTHON_COMPILER_ACTIVE"]=version
+    script=(
+        "import pathlib,hython; from hython.compiler import compile_source; "
+        "from hython.bytecode import dumps,loads; "
+        "p=pathlib.Path(hython.__file__).resolve(); root=pathlib.Path(r'"+str(path).replace("'","''")+"').resolve(); "
+        "assert root in p.parents; dumps(loads(dumps(compile_source('값 = 1 + 2'))))"
+    )
+    result=subprocess.run([sys.executable,"-c",script],env=env,capture_output=True,text=True,timeout=30)
+    if result.returncode:
+        detail=(result.stderr or result.stdout).strip().splitlines()[-1:] or ["알 수 없는 오류"]
+        raise CompilerUpdateError(f"새 컴파일러 smoke test 실패: {detail[0]}")
+
+
+def install_wheel(wheel: Path, *, version: str, sha256: str) -> Path:
+    actual=hashlib.sha256(wheel.read_bytes()).hexdigest()
+    if not __import__("hmac").compare_digest(actual.lower(),sha256.lower()):
+        raise CompilerUpdateError("compiler wheel SHA-256 검증 실패")
+    root=compiler_root(); final=root/version
+    staging=Path(tempfile.mkdtemp(prefix=f".{version}-",dir=root))
+    try:
+        _safe_extract(wheel,staging)
+        _smoke_test(staging,version)
+        if final.exists():
+            shutil.rmtree(final)
+        staging.replace(final)
+    except BaseException:
+        shutil.rmtree(staging,ignore_errors=True)
+        raise
+    _activate(version)
+    return final
+
+
+def update(*, force: bool = False) -> dict:
+    release=check()
+    if not release["update_available"] and not force:
+        return release|{"installed":False}
+    with tempfile.TemporaryDirectory(prefix="hython-compiler-download-") as directory:
+        wheel=Path(directory)/(release.get("filename") or "compiler.whl")
+        _download(release["url"],wheel)
+        install_wheel(wheel,version=release["version"],sha256=release["sha256"])
+    return release|{"installed":True}
+
+
+def _activate(version: str | None) -> None:
+    state=load_state(); previous=state.get("active"); history=list(state.get("history",[]))
+    if previous and previous!=version:
+        history=[item for item in history if item!=previous]+[previous]
+    state={"format":1,"active":version,"history":history[-10:]}
+    _atomic_json(state_path(),state)
+
+
+def rollback() -> str | None:
+    state=load_state(); history=list(state.get("history",[]))
+    while history:
+        version=history.pop()
+        if (compiler_root()/version).is_dir():
+            _atomic_json(state_path(),{"format":1,"active":version,"history":history})
+            return version
+    _activate(None)
+    return None
+
+
+def remove(version: str | None = None) -> str:
+    state=load_state(); target=version or state.get("active")
+    if not isinstance(target,str) or not target:
+        raise CompilerUpdateError("삭제할 외부 컴파일러가 없습니다.")
+    if state.get("active")==target:
+        rollback()
+    path=compiler_root()/target
+    shutil.rmtree(path,ignore_errors=True)
+    state=load_state()
+    state["history"]=[item for item in state.get("history",[]) if item!=target]
+    _atomic_json(state_path(),state)
+    return target
+
+
+def reexec_with_active(argv: list[str]) -> None:
+    version=active_version()
+    if not version or os.environ.get("HYTHON_COMPILER_ACTIVE")==version:
+        return
+    env=os.environ.copy(); env["HYTHON_COMPILER_ACTIVE"]=version
+    env["PYTHONPATH"]=str(compiler_root()/version)+os.pathsep+str(external_source_root())+os.pathsep+env.get("PYTHONPATH","")
+    if is_frozen():
+        from .runtime_manager import find_manager
+        command=[find_manager(),"exec","-V:default","-m","hython",*argv]
+    else:
+        command=[sys.executable,"-m","hython",*argv]
+    result=subprocess.run(command,env=env)
+    raise SystemExit(result.returncode)
+
+
+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

hython/diagnostics.py

@@ -0,0 +1,158 @@
+"""Korean user-facing exception and traceback formatting."""
+
+from __future__ import annotations
+
+import re
+import traceback
+import subprocess
+from pathlib import Path
+
+
+TYPE_NAMES={
+    SyntaxError:"문법 오류",IndentationError:"들여쓰기 오류",TabError:"탭/공백 오류",
+    NameError:"이름 오류",UnboundLocalError:"지역 이름 오류",TypeError:"형식 오류",
+    ValueError:"값 오류",AttributeError:"속성 오류",ImportError:"가져오기 오류",
+    ModuleNotFoundError:"모듈 없음 오류",KeyError:"키 오류",IndexError:"인덱스 오류",
+    ZeroDivisionError:"0 나누기 오류",FileNotFoundError:"파일 없음 오류",
+    PermissionError:"권한 오류",IsADirectoryError:"디렉터리 오류",NotADirectoryError:"경로 오류",
+    AssertionError:"검증 실패",RuntimeError:"실행 오류",RecursionError:"재귀 한도 오류",
+    OverflowError:"범위 초과 오류",MemoryError:"메모리 부족 오류",
+    NotImplementedError:"미구현 오류",TimeoutError:"시간 초과 오류",
+    EOFError:"입력 종료 오류",OSError:"운영체제 오류",
+    BaseExceptionGroup:"예외 묶음",
+}
+
+
+def exception_name(error: BaseException) -> str:
+    for cls in type(error).__mro__:
+        if cls in TYPE_NAMES:
+            return TYPE_NAMES[cls]
+    return type(error).__name__
+
+
+def _replace(message: str, pattern: str, replacement: str) -> str | None:
+    match=re.fullmatch(pattern,message)
+    return match.expand(replacement) if match else None
+
+
+def translated_message(error: BaseException) -> str:
+    message=str(getattr(error,"msg",error)) if isinstance(error,SyntaxError) else str(error)
+    if isinstance(error,FileNotFoundError):
+        target=getattr(error,"filename",None)
+        return f"파일을 찾을 수 없습니다: {target}" if target else "파일을 찾을 수 없습니다."
+    if isinstance(error,PermissionError):
+        target=getattr(error,"filename",None)
+        return f"접근 권한이 없습니다: {target}" if target else "접근 권한이 없습니다."
+    if isinstance(error,subprocess.CalledProcessError):
+        return f"외부 명령이 종료 코드 {error.returncode}로 실패했습니다."
+    if isinstance(error,ModuleNotFoundError):
+        name=getattr(error,"name",None)
+        return f"모듈을 찾을 수 없습니다: {name}" if name else "모듈을 찾을 수 없습니다."
+    if isinstance(error,KeyError):
+        return f"키를 찾을 수 없습니다: {error.args[0]!r}" if error.args else "키를 찾을 수 없습니다."
+    if isinstance(error,AssertionError) and not message:
+        return "검증 조건이 참이 아닙니다."
+    patterns=[]
+    if isinstance(error,(NameError,UnboundLocalError)):
+        patterns=[
+            (r"name '([^']+)' is not defined",r"이름 '\1'이 정의되지 않았습니다."),
+            (r"cannot access local variable '([^']+)' where it is not associated with a value",r"지역 변수 '\1'에 값이 연결되기 전에 접근했습니다."),
+        ]
+    elif isinstance(error,AttributeError):
+        patterns=[(r"'([^']+)' object has no attribute '([^']+)'",r"'\1' 객체에 '\2' 속성이 없습니다."),
+                  (r"module '([^']+)' has no attribute '([^']+)'",r"'\1' 모듈에 '\2' 속성이 없습니다.")]
+    elif isinstance(error,ImportError):
+        patterns=[(r"cannot import name '([^']+)' from '([^']+)'.*",r"'\2'에서 이름 '\1'을 가져올 수 없습니다.")]
+    elif isinstance(error,IndexError):
+        patterns=[(r"list index out of range",r"리스트 인덱스가 범위를 벗어났습니다."),
+                  (r"tuple index out of range",r"튜플 인덱스가 범위를 벗어났습니다."),
+                  (r"string index out of range",r"문자열 인덱스가 범위를 벗어났습니다.")]
+    elif isinstance(error,ZeroDivisionError):
+        patterns=[(r"division by zero",r"0으로 나눌 수 없습니다."),
+                  (r"integer division or modulo by zero",r"0으로 정수 나눗셈 또는 나머지 연산을 할 수 없습니다."),
+                  (r"float division by zero",r"부동소수점 수를 0으로 나눌 수 없습니다."),
+                  (r"complex division by zero",r"복소수를 0으로 나눌 수 없습니다.")]
+    elif isinstance(error,TypeError):
+        patterns=[
+            (r"'([^']+)' object is not callable",r"'\1' 객체는 호출할 수 없습니다."),
+            (r"'([^']+)' object is not iterable",r"'\1' 객체는 반복할 수 없습니다."),
+            (r"'([^']+)' object is not subscriptable",r"'\1' 객체는 첨자로 접근할 수 없습니다."),
+            (r"unsupported operand type\(s\) for (.+): '([^']+)' and '([^']+)'",r"연산자 \1은 '\2'와 '\3' 형식에 사용할 수 없습니다."),
+            (r"(.+) got an unexpected keyword argument '([^']+)'",r"\1에 예상하지 않은 키워드 인자 '\2'이 전달되었습니다."),
+            (r"(.+) got multiple values for argument '([^']+)'",r"\1의 인자 '\2'에 값이 여러 번 전달되었습니다."),
+            (r"(.+) missing (\d+) required positional argument(?:s)?: (.+)",r"\1에 필수 위치 인자 \2개가 없습니다: \3"),
+        ]
+    elif isinstance(error,SyntaxError):
+        patterns=[(r"invalid syntax",r"잘못된 문법입니다."),(r"unexpected EOF while parsing",r"코드가 끝나기 전에 문법이 완성되지 않았습니다."),
+                  (r"expected '([^']+)'",r"'\1'이 필요합니다."),(r"unmatched '([^']+)'",r"짝이 맞지 않는 '\1'가 있습니다."),
+                  (r"unterminated (.+)",r"닫히지 않은 \1입니다.")]
+    elif isinstance(error,RecursionError):
+        patterns=[(r"maximum recursion depth exceeded.*",r"최대 재귀 깊이를 초과했습니다.")]
+    for pattern,replacement in patterns:
+        result=_replace(message,pattern,replacement)
+        if result is not None:
+            return result
+    return message or exception_name(error)
+
+
+def _user_frames(error: BaseException) -> list[traceback.FrameSummary]:
+    frames=list(traceback.extract_tb(error.__traceback__))
+    package=Path(__file__).resolve().parent
+    visible=[]
+    for frame in frames:
+        normalized=frame.filename.replace("\\","/")
+        try:
+            internal=Path(frame.filename).resolve().is_relative_to(package)
+        except (OSError,ValueError):
+            internal=False
+        internal=internal or normalized.startswith("hython/") or "/hython/" in normalized
+        internal=internal or Path(normalized).name in {"code.py","codeop.py"}
+        if not internal or frame.filename.startswith("<") or frame.filename.endswith((".hy",".hbc")):
+            visible.append(frame)
+    return visible
+
+
+def _single(error: BaseException, *, indent: str = "", traceback_enabled: bool = True) -> list[str]:
+    lines=[]
+    if isinstance(error,SyntaxError) and getattr(error,"lineno",None):
+        lines.append(indent+f'  파일 "{error.filename or "<하이썬>"}", 줄 {error.lineno}')
+        source=(error.text or "").rstrip("\r\n")
+        if source:
+            lines.append(indent+"    "+source)
+            if error.offset:
+                end=max(error.offset,getattr(error,"end_offset",error.offset) or error.offset)
+                lines.append(indent+"    "+" "*(max(error.offset-1,0))+"^"*max(end-error.offset,1))
+    if traceback_enabled:
+        frames=_user_frames(error)
+        if frames:
+            lines.append(indent+"하이썬 추적 (가장 최근 호출이 마지막):")
+            for frame in frames:
+                lines.append(indent+f'  파일 "{frame.filename}", 줄 {frame.lineno}, 함수 {frame.name}')
+                if frame.line: lines.append(indent+"    "+frame.line.strip())
+    lines.append(indent+f"{exception_name(error)}: {translated_message(error)}")
+    for note in getattr(error,"__notes__",()) or ():
+        lines.append(indent+f"  참고: {note}")
+    return lines
+
+
+def format_exception(error: BaseException, *, traceback_enabled: bool = True) -> str:
+    """Format chaining and exception groups without exposing Hython internals."""
+    lines=[]; seen=set()
+    def render(current: BaseException,indent=""):
+        if id(current) in seen: return
+        seen.add(id(current))
+        cause=current.__cause__
+        context=current.__context__ if not current.__suppress_context__ else None
+        if cause is not None:
+            render(cause,indent); lines.append(indent+"위 오류가 다음 오류의 직접 원인입니다:")
+        elif context is not None:
+            render(context,indent); lines.append(indent+"위 오류를 처리하는 동안 다른 오류가 발생했습니다:")
+        if isinstance(current,BaseExceptionGroup):
+            lines.extend(_single(current,indent=indent,traceback_enabled=traceback_enabled))
+            for index,child in enumerate(current.exceptions,1):
+                lines.append(indent+f"  하위 오류 {index}:")
+                render(child,indent+"    ")
+        else:
+            lines.extend(_single(current,indent=indent,traceback_enabled=traceback_enabled))
+    render(error)
+    return "\n".join(lines)

hython/environment.py

@@ -0,0 +1,48 @@
+"""Shared paths for source and frozen Hython distributions."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+def is_frozen() -> bool:
+    return bool(getattr(sys,"frozen",False) or "__compiled__" in globals() or os.environ.get("HYTHON_FROZEN"))
+
+
+def hython_home() -> Path:
+    root=Path(os.environ.get("HYTHON_HOME",Path.home()/".hython"))
+    root.mkdir(parents=True,exist_ok=True)
+    return root
+
+
+def external_source_root() -> Path:
+    configured=os.environ.get("HYTHON_BUNDLED_SOURCE")
+    if configured:
+        return Path(configured)
+    if is_frozen():
+        base=Path(getattr(sys,"_MEIPASS",Path(sys.argv[0]).resolve().parent))
+        return base/"hython_source"
+    return Path(__file__).resolve().parents[1]
+
+
+def package_store() -> Path:
+    path=hython_home()/"packages"/f"python-{sys.version_info.major}.{sys.version_info.minor}"
+    path.mkdir(parents=True,exist_ok=True)
+    return path
+
+
+def activate_package_store() -> Path:
+    path=package_store()
+    value=str(path)
+    if value not in sys.path:
+        sys.path.insert(0,value)
+    return path
+
+
+def display_executable() -> Path:
+    """Return the user-launched executable, not a onefile extraction helper."""
+    if is_frozen() and sys.argv:
+        return Path(sys.argv[0]).resolve()
+    return Path(sys.executable).resolve()