xython 4.6.4__tar.gz → 4.7.1__tar.gz

{xython-4.6.4/src/xython.egg-info → xython-4.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xython
-Version: 4.6.4
+Version: 4.7.1
 Summary: xython package
 Author-email: "SJ.Park" <sjpkorea@naver.com>
 License: MIT

{xython-4.6.4 → xython-4.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xython"
-version = "4.6.4"
+version = "4.7.1"
 description = "xython package"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.8"

{xython-4.6.4 → xython-4.7.1}/src/xython/__init__.py

@@ -1,12 +1,12 @@
 # __init__.py
-# Copyright (C) 2026 (sjpkorea@naver.com) and contributors
+# Copyright (C) 2025 (sjpkorea@naver.com) and contributors
+
 
-#https://blog.naver.com/xython
 import inspect
 import os
 import sys
 
-__version__ = '4.4.3' #1
+__version__ = '4.3.5' #1
 real_path = os.path.dirname(os.path.abspath(__file__)).replace("\\","/") #2
 sys.path.append(real_path)
 

xython-4.7.1/src/xython/alias_installer.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+"""
+alias_installer.py  (개선판 - 각 모듈의 호출부는 그대로 두면 됨)
+
+방식: 인스턴스마다 alias 를 setattr 하지 않고, __getattr__ 에서 '처음 쓸 때' 만든다.
+  - 인스턴스 생성이 가볍다 (280개 wrapper 를 매번 만들지 않음)
+  - alias -> 원본 역방향 표를 (모듈, 언어) 단위로 1번만 만들고 캐시
+  - 만든 wrapper 는 클래스 단위로 캐시하고, 인스턴스에는 바인딩만 한다
+    (인스턴스 __dict__ 가 깨끗해서 pickle / copy.deepcopy 도 안전)
+  - functools.wraps 로 원본 시그니처 유지 -> help(), IDE 에서 인자 목록이 보인다
+  - make_dir_fallback 을 쓰면 dir()/탭 자동완성에도 alias 가 보인다
+"""
+import difflib, types
+import functools
+from functools import lru_cache
+
+from .locales_loader import load_locales_for_module
+
+
+def _normalize_langs(lang):
+    if lang is None:
+        return ()
+    if isinstance(lang, str):
+        return (lang,)
+    return tuple(lang)
+
+
+def build_combined_doc(orig_name, locales, active_langs):
+    """여러 언어의 doc 을 순서대로 이어 붙인 docstring 생성."""
+    lines = []
+    for lang in active_langs:
+        doc = locales.get(lang, {}).get("docs", {}).get(orig_name)
+        if doc:
+            lines.append(f"[{lang}] {doc}")
+    return "\n".join(lines) if lines else None
+
+
+@lru_cache(maxsize=None)
+def _alias_table(module_name, langs):
+    """(alias -> 원본이름) 역방향 표와 locales 를 반환. langs 는 tuple."""
+    locales = load_locales_for_module(module_name, langs)
+    reverse = {}
+    for lg in langs:
+        for orig, alias in locales[lg]["aliases"].items():
+            if alias and alias != orig:          # 빈 문자열(미번역)은 무시
+                reverse.setdefault(alias, orig)  # 충돌 시 앞쪽 언어가 우선
+    return reverse, locales
+
+
+@lru_cache(maxsize=None)
+def _make_alias_function(owner_cls, module_name, orig_name, alias_name, langs):
+    orig_func = getattr(owner_cls, orig_name, None)
+    if orig_func is None or not callable(orig_func):
+        return None
+
+    _, locales = _alias_table(module_name, langs)
+    doc = build_combined_doc(orig_name, locales, langs) or orig_func.__doc__
+
+    @functools.wraps(orig_func)
+    def wrapper(self, *args, **kwargs):
+        return orig_func(self, *args, **kwargs)
+
+    wrapper.__name__ = alias_name
+    wrapper.__qualname__ = f"{owner_cls.__name__}.{alias_name}"
+    wrapper.__doc__ = doc
+    return wrapper
+
+
+# alias_installer.py
+def install_instance_aliases(instance, module_name, active_langs):
+    langs = _normalize_langs(active_langs)
+    reverse, _ = _alias_table(module_name, langs)          # JSON 캐시 데움
+    owner_cls = type(instance)
+    for alias_name in reverse:
+        # 클래스에 이미 있으면(@alias 로 등록된 것) 건너뜀 → 충돌 방지
+        if hasattr(owner_cls, alias_name):
+            continue
+        func = _make_alias_function(owner_cls, module_name,
+                                    reverse[alias_name], alias_name, langs)
+        if func is not None:
+            # 인스턴스에 바인딩 (인스턴스마다 wrapper 1개씩 생김 — 비용 있음)
+            setattr(instance, alias_name, types.MethodType(func, instance))
+
+
+def make_getattr_fallback(module_name):
+    """클래스에 `__getattr__ = make_getattr_fallback("xy_time")` 로 붙인다."""
+    def _getattr(self, name):
+        if name.startswith("__") and name.endswith("__"):
+            raise AttributeError(name)
+
+        langs = _normalize_langs(self.__dict__.get("lang"))
+        msg = f"'{type(self).__name__}' object has no attribute '{name}'"
+
+        if langs:
+            reverse, _ = _alias_table(module_name, langs)
+            orig = reverse.get(name)
+            if orig is not None:
+                func = _make_alias_function(type(self), module_name, orig, name, langs)
+                if func is not None:
+                    return func.__get__(self, type(self))
+            close = difflib.get_close_matches(name, reverse, n=1)
+            if close:
+                msg += f". Did you mean '{close[0]}'?"
+
+        raise AttributeError(msg)
+
+    return _getattr
+
+
+def make_dir_fallback(module_name):
+    """(선택) 클래스에 `__dir__ = make_dir_fallback("xy_time")` 를 붙이면 자동완성에 alias 가 보인다."""
+    def _dir(self):
+        names = set(object.__dir__(self))
+        langs = _normalize_langs(self.__dict__.get("lang"))
+        if langs:
+            names.update(_alias_table(module_name, langs)[0])
+        return sorted(names)
+
+    return _dir

xython-4.7.1/src/xython/locales_loader.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""
+locales_loader.py
+
+locales/{lang}/{module_name}.json 을 읽어서 dict 로 반환.
+- aliases : {원본함수명: 언어별이름}
+- docs    : {원본함수명: 언어별설명}
+"""
+import json
+import os
+
+_LOCALES_DIR = os.path.join(os.path.dirname(__file__), "locales")
+_cache = {}
+
+
+def load_locale(module_name, lang):
+    key = (module_name, lang)
+    if key in _cache:
+        return _cache[key]
+
+    path = os.path.join(_LOCALES_DIR, lang, f"{module_name}.json")
+    if not os.path.exists(path):
+        _cache[key] = {"aliases": {}, "docs": {}}
+        return _cache[key]
+
+    try:
+        # utf-8-sig: 윈도우 메모장/일부 에디터가 붙이는 BOM 이 있어도 읽힌다
+        with open(path, "r", encoding="utf-8-sig") as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"locale 파일 JSON 오류: {path} ({e})") from e
+
+    result = {
+        "aliases": data.get("aliases", {}),
+        "docs": data.get("docs", {}),
+    }
+    _cache[key] = result
+    return result
+
+
+def load_locales_for_module(module_name, langs):
+    return {lang: load_locale(module_name, lang) for lang in langs}
+
+
+def clear_cache():
+    """JSON 을 고친 뒤 재시작 없이 다시 읽고 싶을 때 (GUI/테스트용)."""
+    _cache.clear()
+    try:
+        from .alias_installer import _alias_table, _make_alias_function
+        _alias_table.cache_clear()
+        _make_alias_function.cache_clear()
+    except ImportError:
+        pass