hossam 0.3.16__py3-none-any.whl → 0.3.18__py3-none-any.whl

hossam/__init__.py

@@ -5,6 +5,7 @@ from matplotlib import font_manager as fm
 from importlib.resources import files, as_file
 from importlib.metadata import version
 from types import SimpleNamespace
+import sys
 import warnings
 
 try:
@@ -56,9 +57,10 @@ def _init_korean_font():
                 "pdf.fonttype": 42,
                 "ps.fonttype": 42,
             })
-            print(
-                "\n✅ 시각화를 위한 한글 글꼴(NotoSansKR-Regular)이 자동 적용되었습니다."
-            )
+            if sys.stdout.isatty():
+                print(
+                    "\n✅ 시각화를 위한 한글 글꼴(NotoSansKR-Regular)이 자동 적용되었습니다."
+                )
             return
     except Exception as e:
         warnings.warn(f"\n한글 폰트 초기화: 패키지 폰트 사용 실패 ({e}).")
@@ -76,8 +78,10 @@ def _init():
         f"🔖 Version: {__version__}",
     ]
 
-    for msg in messages:
-        print(f"{msg}")
+    # MCP/stdio 환경에서는 배너를 출력하지 않음 (stdout TTY일 때만 출력)
+    if sys.stdout.isatty():
+        for msg in messages:
+            print(f"{msg}")
 
     _init_korean_font()
 

hossam/hs_prep.py

@@ -440,11 +440,11 @@ def bin_continuous(
 
     지원 방법:
     - "natural_breaks"(기본): Jenks 자연 구간화. jenkspy 미사용 시 quantile로 대체
-      기본 라벨: "X~Y" 형식 (예: "18~30", "30~40")
+      기본 라벨: "X-Y" 형식 (예: "18-30", "30-40")
     - "quantile"/"qcut"/"equal_freq": 분위수 기반 동빈도
-      기본 라벨: "X~Y" 형식
+      기본 라벨: "X-Y" 형식
     - "equal_width"/"uniform": 동일 간격
-      기본 라벨: "X~Y" 형식
+      기본 라벨: "X-Y" 형식
     - "std": 평균±표준편차를 경계로 4구간 생성
       라벨: "low", "mid_low", "mid_high", "high"
     - "lifecourse"/"life_stage": 생애주기 5단계

hossam/hs_stats.py

@@ -6,7 +6,7 @@ import numpy as np
 from typing import Tuple
 from itertools import combinations
 from pandas import DataFrame, Series, concat
-from pandas.api.types import is_bool_dtype
+from pandas.api.types import is_bool_dtype, is_numeric_dtype
 
 from sklearn.metrics import (
     confusion_matrix,
@@ -274,7 +274,7 @@ def category_table(data: DataFrame, *fields: str):
 # ===================================================================
 # 범주형 변수 요약 (Categorical Variable Summary)
 # ===================================================================
-def category_summary(data: DataFrame, *fields: str):
+def category_describe(data: DataFrame, *fields: str):
     """데이터프레임의 명목형(범주형) 변수에 대한 분포 편향을 요약한다.
 
     각 명목형 컬럼의 최다 범주와 최소 범주의 정보를 요약하여 데이터프레임으로 반환한다.
@@ -296,19 +296,19 @@ def category_summary(data: DataFrame, *fields: str):
     Examples:
         전체 명목형 컬럼에 대한 분포 편향 요약:
 
-        >>> from hossam import category_summary
+        >>> from hossam import category_describe
         >>> import pandas as pd
         >>> df = pd.DataFrame({
         ...     'cut': ['Ideal', 'Premium', 'Good', 'Ideal', 'Premium'],
         ...     'color': ['E', 'F', 'G', 'E', 'F'],
         ...     'price': [100, 200, 150, 300, 120]
         ... })
-        >>> result = category_summary(df)
+        >>> result = category_describe(df)
         >>> print(result)
 
         특정 컬럼만 분석:
 
-        >>> result = category_summary(df, 'cut', 'color')
+        >>> result = category_describe(df, 'cut', 'color')
         >>> print(result)
 
     Notes:
@@ -360,6 +360,16 @@ def category_summary(data: DataFrame, *fields: str):
 
     return DataFrame(result)
 
+# -------------------------------------------------------------------
+# Backward-compatibility alias for categorical summary
+# 기존 함수명(category_summary)을 계속 지원합니다.
+def category_summary(data: DataFrame, *fields: str):
+    """Deprecated alias for category_describe.
+
+    기존 코드 호환을 위해 유지됩니다. 내부적으로 category_describe를 호출합니다.
+    """
+    return category_describe(data, *fields)
+
 # ===================================================================
 # 정규성 검정 (Normal Test)
 # ===================================================================
@@ -443,7 +453,7 @@ def normal_test(data: DataFrame, columns: list | str | None = None, method: str
             if method == "n":
                 method_name = "normaltest"
                 s, p = normaltest(col_data)
-            else:  # method == "s"
+            else:
                 method_name = "shapiro"
                 s, p = shapiro(col_data)
 
@@ -1028,6 +1038,16 @@ def vif_filter(
 
     return result
 
+# -------------------------------------------------------------------
+# Backward-compatibility alias for describe (typo support)
+# 오타(discribe)로 사용된 경우를 지원하여 혼란을 줄입니다.
+def discribe(data: DataFrame, *fields: str, columns: list = None):
+    """Deprecated alias for describe.
+
+    내부적으로 describe를 호출합니다.
+    """
+    return describe(data, *fields, columns=columns)
+
 
 # ===================================================================
 # x, y 데이터에 대한 추세선을 구한다.
@@ -1298,14 +1318,14 @@ def ols(df: DataFrame, yname: str, report=False):
         ...     'x2': np.random.normal(0, 1, 100)
         ... })
         >>> # 적합 결과만 반환
-        >>> fit = hs_linear(df, 'target')
+        >>> fit = hs_ols(df, 'target')
         >>> print(fit.summary())
 
         >>> # 요약 리포트 반환
-        >>> fit, rdf, result_report, model_report, var_reports, eq = hs_linear(df, 'target', report=1)
+        >>> fit, result, features = hs_ols(df, 'target', report=1)
 
         >>> # 풀 리포트 반환
-        >>> fit, pdf, rdf, result_report, model_report, var_reports, eq = hs_linear(df, 'target', report=2)
+        >>> fit, pdf, rdf, result_report, model_report, var_reports, eq = hs_ols(df, 'target', report=2)
     """
     x = df.drop(yname, axis=1)
     y = df[yname]
@@ -1320,8 +1340,8 @@ def ols(df: DataFrame, yname: str, report=False):
         return linear_fit
     elif report == 1 or report == 'summary':
         # 요약 리포트 (full=False)
-        result = ols_report(linear_fit, df, full=False, alpha=0.05)
-        return linear_fit, result
+        pdf, rdf, result_report, model_report, variable_reports, equation_text = ols_report(linear_fit, df, full=True, alpha=0.05)
+        return linear_fit, pdf, rdf
     elif report == 2 or report == 'full' or report is True:
         # 풀 리포트 (full=True)
         pdf, rdf, result_report, model_report, variable_reports, equation_text = ols_report(linear_fit, df, full=True, alpha=0.05)
@@ -2094,7 +2114,7 @@ def corr_pairwise(
         cols = data.select_dtypes(include=[np.number]).columns.tolist()
     else:
         # fields 리스트에서 데이터에 있는 것만 선택하되, 숫자형만 필터링
-        cols = [c for c in fields if c in data.columns and pd.api.types.is_numeric_dtype(data[c])]
+        cols = [c for c in fields if c in data.columns and is_numeric_dtype(data[c])]
 
     # 사용 가능한 컬럼이 2개 미만이면 상관분석 불가능
     if len(cols) < 2:
@@ -2707,7 +2727,7 @@ def predict(fit, data: DataFrame | Series) -> DataFrame | Series | float:
 # ===================================================================
 # 확장된 기술통계량 (Extended Descriptive Statistics)
 # ===================================================================
-def summary(data: DataFrame, *fields: str, columns: list = None):
+def describe(data: DataFrame, *fields: str, columns: list = None):
     """데이터프레임의 연속형 변수에 대한 확장된 기술통계량을 반환한다.
 
     각 연속형(숫자형) 컬럼의 기술통계량(describe)을 구하고, 이에 사분위수 범위(IQR),
@@ -2854,3 +2874,119 @@ def summary(data: DataFrame, *fields: str, columns: list = None):
         result = result[columns]
 
     return result
+
+
+# ===================================================================
+# 상관계수 및 효과크기 분석 (Correlation & Effect Size)
+# ===================================================================
+def corr_effect_size(data: DataFrame, dv: str, *fields: str, alpha: float = 0.05) -> DataFrame:
+    """종속변수와의 편상관계수 및 효과크기를 계산한다.
+
+    각 독립변수와 종속변수 간의 상관계수를 계산하되, 정규성과 선형성을 검사하여
+    Pearson 또는 Spearman 상관계수를 적절히 선택한다.
+    Cohen's d (효과크기)를 계산하여 상관 강도를 정량화한다.
+
+    Args:
+        data (DataFrame): 분석 대상 데이터프레임.
+        dv (str): 종속변수 컬럼 이름.
+        *fields (str): 독립변수 컬럼 이름들. 지정하지 않으면 수치형 컬럼 중 dv 제외 모두 사용.
+        alpha (float, optional): 유의수준. 기본 0.05.
+
+    Returns:
+        DataFrame: 다음 컬럼을 포함한 데이터프레임:
+            - Variable (str): 독립변수 이름
+            - Correlation (float): 상관계수 (Pearson 또는 Spearman)
+            - Corr_Type (str): 선택된 상관계수 종류 ('Pearson' 또는 'Spearman')
+            - P-value (float): 상관계수의 유의확률
+            - Cohens_d (float): 표준화된 효과크기
+            - Effect_Size (str): 효과크기 분류 ('Large', 'Medium', 'Small', 'Negligible')
+
+    Examples:
+        >>> from hossam import hs_stats
+        >>> import pandas as pd
+        >>> df = pd.DataFrame({'age': [20, 30, 40, 50],
+        ...                     'bmi': [22, 25, 28, 30],
+        ...                     'charges': [1000, 2000, 3000, 4000]})
+        >>> result = hs_stats.corr_effect_size(df, 'charges', 'age', 'bmi')
+        >>> print(result)
+    """
+
+    # fields가 지정되지 않으면 수치형 컬럼 중 dv 제외 모두 사용
+    if not fields:
+        fields = [col for col in data.columns
+                 if is_numeric_dtype(data[col]) and col != dv]
+
+    # dv가 수치형인지 확인
+    if not is_numeric_dtype(data[dv]):
+        raise ValueError(f"Dependent variable '{dv}' must be numeric type")
+
+    results = []
+
+    for var in fields:
+        if not is_numeric_dtype(data[var]):
+            continue
+
+        # 결측치 제거
+        valid_idx = data[[var, dv]].notna().all(axis=1)
+        x = data.loc[valid_idx, var].values
+        y = data.loc[valid_idx, dv].values
+
+        if len(x) < 3:
+            continue
+
+        # 정규성 검사 (Shapiro-Wilk: n <= 5000 권장, 그 외 D'Agostino)
+        method_x = 's' if len(x) <= 5000 else 'n'
+        method_y = 's' if len(y) <= 5000 else 'n'
+
+        normal_x_result = normal_test(data[[var]], columns=[var], method=method_x)
+        normal_y_result = normal_test(data[[dv]], columns=[dv], method=method_y)
+
+        # 정규성 판정 (p > alpha면 정규분포 가정)
+        normal_x = normal_x_result.loc[var, 'p-val'] > alpha if var in normal_x_result.index else False
+        normal_y = normal_y_result.loc[dv, 'p-val'] > alpha if dv in normal_y_result.index else False
+
+        # Pearson (모두 정규) vs Spearman (하나라도 비정규)
+        if normal_x and normal_y:
+            r, p = pearsonr(x, y)
+            corr_type = 'Pearson'
+        else:
+            r, p = spearmanr(x, y)
+            corr_type = 'Spearman'
+
+        # Cohen's d 계산 (상관계수에서 효과크기로 변환)
+        # d = 2*r / sqrt(1-r^2)
+        if r**2 < 1:
+            d = (2 * r) / np.sqrt(1 - r**2)
+        else:
+            d = 0
+
+        # 효과크기 분류 (Cohen's d 기준)
+        # Small: 0.2 < |d| <= 0.5
+        # Medium: 0.5 < |d| <= 0.8
+        # Large: |d| > 0.8
+        abs_d = abs(d)
+        if abs_d > 0.8:
+            effect_size = 'Large'
+        elif abs_d > 0.5:
+            effect_size = 'Medium'
+        elif abs_d > 0.2:
+            effect_size = 'Small'
+        else:
+            effect_size = 'Negligible'
+
+        results.append({
+            'Variable': var,
+            'Correlation': r,
+            'Corr_Type': corr_type,
+            'P-value': p,
+            'Cohens_d': d,
+            'Effect_Size': effect_size
+        })
+
+    result_df = DataFrame(results)
+
+    # 상관계수로 정렬 (절댓값 기준 내림차순)
+    if len(result_df) > 0:
+        result_df = result_df.sort_values('Correlation', key=lambda x: x.abs(), ascending=False).reset_index(drop=True)
+
+    return result_df

hossam/mcp/__init__.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+"""
+Hossam MCP Layer
+
+- 기존 공개 API는 유지하며, MCP 관련 코드는 이 패키지 내부에만 위치합니다.
+- 서버는 명시적 엔트리포인트로만 실행됩니다 (`hossam-mcp`).
+- 각 모듈별 `register(mcp)` 함수를 통해 MCP tool을 등록합니다.
+"""
+
+__all__ = [
+    "server",
+]

hossam/mcp/hs_classroom.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_classroom"""
+def register(mcp):
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_classroom as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_classroom_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_gis.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_gis"""
+def register(mcp):
+    from hossam.hs_gis import save_shape as _save_shape
+
+    @mcp.tool("hs_gis_save_shape")
+    def hs_save_shape(gdf_or_df, path: str, crs: str | None = None, lat_col: str = "latitude", lon_col: str = "longitude"):
+        """GeoDataFrame 또는 DataFrame을 Shapefile/GeoPackage로 저장합니다."""
+        _save_shape(gdf_or_df, path=path, crs=crs, lat_col=lat_col, lon_col=lon_col)
+        return {"saved": True, "path": path}
+
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_gis as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_gis_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_plot.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_plot
+
+시각화 함수는 파일 저장 경로(`save_path`)를 활용하는 사용을 권장합니다.
+"""
+from typing import Any
+from pandas import DataFrame
+
+from hossam.hs_plot import (
+    lineplot as _lineplot,
+    boxplot as _boxplot,
+    kdeplot as _kdeplot,
+)
+
+
+def register(mcp):
+    # @mcp.tool("hs_lineplot")
+    # def hs_lineplot(df: DataFrame, xname: str | None = None, yname: str | None = None, hue: str | None = None, save_path: str | None = None, **params: Any):
+    #     """선 그래프를 그립니다. 원격 환경에서는 `save_path`로 저장하여 활용하세요."""
+    #     _lineplot(df=df, xname=xname, yname=yname, hue=hue, save_path=save_path, **params)
+    #     return {"saved": bool(save_path), "path": save_path}
+
+    # @mcp.tool("hs_boxplot")
+    # def hs_boxplot(df: DataFrame, xname: str | None = None, yname: str | None = None, orient: str = "v", save_path: str | None = None, **params: Any):
+    #     """상자그림(boxplot)을 그립니다. `save_path` 지정 시 파일로 저장합니다."""
+    #     _boxplot(df=df, xname=xname, yname=yname, orient=orient, save_path=save_path, **params)
+    #     return {"saved": bool(save_path), "path": save_path}
+
+    # @mcp.tool("hs_kdeplot")
+    # def hs_kdeplot(df: DataFrame, xname: str | None = None, yname: str | None = None, hue: str | None = None, fill: bool = False, quartile_split: bool = False, save_path: str | None = None, **params: Any):
+    #     """KDE(커널 밀도) 그래프를 그립니다. 1D KDE는 `quartile_split`로 사분위별 분할 가능."""
+    #     _kdeplot(df=df, xname=xname, yname=yname, hue=hue, fill=fill, quartile_split=quartile_split, save_path=save_path, **params)
+    #     return {"saved": bool(save_path), "path": save_path}
+
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_plot as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_plot_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_prep.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_prep"""
+from typing import List
+from pandas import DataFrame
+
+from hossam.hs_prep import (
+    standard_scaler as _standard_scaler,
+    minmax_scaler as _minmax_scaler,
+    set_category as _set_category,
+    get_dummies as _get_dummies,
+    replace_outliner as _replace_outliner,
+)
+
+
+def register(mcp):
+    # @mcp.tool("hs_standard_scaler")
+    # def hs_standard_scaler(data: DataFrame | list | dict, yname: str | None = None, save_path: str | None = None, load_path: str | None = None):
+    #     """연속형 변수에 대해 Z-Score(Standard) 스케일링을 수행합니다."""
+    #     return _standard_scaler(data, yname=yname, save_path=save_path, load_path=load_path)
+
+    # @mcp.tool("hs_minmax_scaler")
+    # def hs_minmax_scaler(data: DataFrame | list | dict, yname: str | None = None, save_path: str | None = None, load_path: str | None = None):
+    #     """연속형 변수를 0~1로 정규화(MinMax Scaling)합니다."""
+    #     return _minmax_scaler(data, yname=yname, save_path=save_path, load_path=load_path)
+
+    # @mcp.tool("hs_set_category")
+    # def hs_set_category(df: DataFrame, fields: List[str]):
+    #     """지정된 컬럼을 pandas Categorical로 설정합니다."""
+    #     return _set_category(df, *fields)
+
+    # @mcp.tool("hs_get_dummies")
+    # def hs_get_dummies(df: DataFrame, fields: List[str] | None = None, drop_first: bool = True, dtype: str = "int"):
+    #     """명목형 변수를 더미 변수(원-핫)로 변환합니다."""
+    #     fields = fields or []
+    #     return _get_dummies(df, *fields, drop_first=drop_first, dtype=dtype)
+
+    # @mcp.tool("hs_replace_outliner")
+    # def hs_replace_outliner(df: DataFrame, method: str = "nan", fields: List[str] | None = None):
+    #     """IQR 기준 이상치를 지정된 방식으로 대체합니다."""
+    #     fields = fields or []
+    #     return _replace_outliner(df, method=method, *fields)
+
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_prep as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_prep_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_stats.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_stats
+
+공개 API만 thin wrapper로 노출합니다.
+"""
+def register(mcp):
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_stats as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_stats_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_timeserise.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_timeserise"""
+def register(mcp):
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_timeserise as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_timeserise_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/hs_util.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""MCP wrappers for hossam.hs_util"""
+def register(mcp):
+    # @mcp.tool("hs_pretty_table")
+    # def hs_pretty_table(df, tablefmt: str = "simple", headers: str | list = "keys"):
+    #     """DataFrame을 단순 표 형태로 출력합니다. 원격 환경에서는 표 문자열을 반환합니다."""
+    #     # pretty_table은 print만 수행하므로, 문자열을 반환하도록 보정
+    #     from tabulate import tabulate
+    #     s = tabulate(df, headers=headers, tablefmt=tablefmt, showindex=True, numalign="right")
+    #     return s
+
+    # 자동 등록: 언더바로 시작하지 않는 모든 공개 함수 노출(중복 방지)
+    import inspect as _inspect
+    import functools as _functools
+    import hossam.hs_util as _mod
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        _tool_name = f"hs_util_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, tool_name=_tool_name):
+            @mcp.tool(tool_name, description=fn.__doc__)
+            @_functools.wraps(fn)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()

hossam/mcp/loader.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+"""MCP auto-wrappers for hossam.data_loader
+
+공개 함수(언더바 미사용) 전체를 MCP tool로 자동 등록합니다.
+단, load_data는 hs_util.load_data로 대체되므로 제외합니다.
+"""
+import inspect as _inspect
+import hossam.data_loader as _mod
+
+
+def register(mcp):
+    # load_data는 제외 (hs_util.load_data를 사용)
+    excluded_functions = ["load_data"]
+
+    for _name, _fn in _inspect.getmembers(_mod, _inspect.isfunction):
+        if _name.startswith("_"):
+            continue
+        if _name in excluded_functions:
+            continue
+        _tool_name = f"hs_data_{_name}"
+        if mcp.get_tool_info(_tool_name):
+            continue
+
+        def _make_tool(fn=_fn, name=_name):
+            @mcp.tool(name)
+            def _tool(**kwargs):
+                return fn(**kwargs)
+
+        _make_tool()