hossam 0.3.15__py3-none-any.whl → 0.3.17__py3-none-any.whl

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:
@@ -2702,3 +2722,271 @@ def predict(fit, data: DataFrame | Series) -> DataFrame | Series | float:
             f"모형 학습 시 사용한 특성과 입력 데이터의 특성이 일치하는지 확인하세요.\n"
             f"원본 오류: {str(e)}"
         )
+
+
+# ===================================================================
+# 확장된 기술통계량 (Extended Descriptive Statistics)
+# ===================================================================
+def describe(data: DataFrame, *fields: str, columns: list = None):
+    """데이터프레임의 연속형 변수에 대한 확장된 기술통계량을 반환한다.
+
+    각 연속형(숫자형) 컬럼의 기술통계량(describe)을 구하고, 이에 사분위수 범위(IQR),
+    이상치 경계값(UP, DOWN), 왜도(skew), 이상치 개수 및 비율, 분포 특성, 로그변환 필요성을
+    추가하여 반환한다.
+
+    Args:
+        data (DataFrame): 분석 대상 데이터프레임.
+        *fields (str): 분석할 컬럼명 목록. 지정하지 않으면 모든 숫자형 컬럼을 처리.
+        columns (list, optional): 반환할 통계량 컬럼 목록. None이면 모든 통계량 반환.
+
+    Returns:
+        DataFrame: 각 필드별 확장된 기술통계량을 포함한 데이터프레임.
+            행은 다음과 같은 통계량을 포함:
+
+            - count (float): 비결측치의 수
+            - mean (float): 평균값
+            - std (float): 표준편차
+            - min (float): 최소값
+            - 25% (float): 제1사분위수 (Q1)
+            - 50% (float): 제2사분위수 (중앙값)
+            - 75% (float): 제3사분위수 (Q3)
+            - max (float): 최대값
+            - iqr (float): 사분위 범위 (Q3 - Q1)
+            - up (float): 이상치 상한 경계값 (Q3 + 1.5 * IQR)
+            - down (float): 이상치 하한 경계값 (Q1 - 1.5 * IQR)
+            - skew (float): 왜도
+            - outlier_count (int): 이상치 개수
+            - outlier_rate (float): 이상치 비율(%)
+            - dist (str): 분포 특성 ("극단 우측 꼬리", "거의 대칭" 등)
+            - log_need (str): 로그변환 필요성 ("높음", "중간", "낮음")
+
+    Examples:
+        전체 숫자형 컬럼에 대한 확장된 기술통계:
+
+        >>> from hossam import summary
+        >>> import pandas as pd
+        >>> df = pd.DataFrame({
+        ...     'x': [1, 2, 3, 4, 5, 100],
+        ...     'y': [10, 20, 30, 40, 50, 60],
+        ...     'z': ['a', 'b', 'c', 'd', 'e', 'f']
+        ... })
+        >>> result = summary(df)
+        >>> print(result)
+
+        특정 컬럼만 분석:
+
+        >>> result = summary(df, 'x', 'y')
+        >>> print(result)
+
+    Notes:
+        - 숫자형이 아닌 컬럼은 자동으로 제외됩니다.
+        - 결과는 필드(컬럼)가 행으로, 통계량이 열로 구성됩니다.
+        - Tukey의 1.5 * IQR 규칙을 사용하여 이상치를 판정합니다.
+        - 분포 특성은 왜도 값으로 판정합니다.
+        - 로그변환 필요성은 왜도의 절댓값 크기로 판정합니다.
+    """
+    if not fields:
+        fields = data.select_dtypes(include=['int', 'int32', 'int64', 'float', 'float32', 'float64']).columns
+
+    # 기술통계량 구하기
+    desc = data[list(fields)].describe().T
+
+    # 추가 통계량 계산
+    additional_stats = []
+    for f in fields:
+        # 숫자 타입이 아니라면 건너뜀
+        if data[f].dtype not in [
+            'int',
+            'int32',
+            'int64',
+            'float',
+            'float32',
+            'float64',
+            'int64',
+            'float64',
+            'float32'
+        ]:
+            continue
+
+        # 사분위수
+        q1 = data[f].quantile(q=0.25)
+        q3 = data[f].quantile(q=0.75)
+
+        # 이상치 경계 (Tukey's fences)
+        iqr = q3 - q1
+        down = q1 - 1.5 * iqr
+        up = q3 + 1.5 * iqr
+
+        # 왜도
+        skew = data[f].skew()
+
+        # 이상치 개수 및 비율
+        outlier_count = ((data[f] < down) | (data[f] > up)).sum()
+        outlier_rate = (outlier_count / len(data)) * 100
+
+        # 분포 특성 판정 (왜도 기준)
+        abs_skew = abs(skew)
+        if abs_skew < 0.5:
+            dist = "거의 대칭"
+        elif abs_skew < 1.0:
+            if skew > 0:
+                dist = "약한 우측 꼬리"
+            else:
+                dist = "약한 좌측 꼬리"
+        elif abs_skew < 2.0:
+            if skew > 0:
+                dist = "중간 우측 꼬리"
+            else:
+                dist = "중간 좌측 꼬리"
+        else:
+            if skew > 0:
+                dist = "극단 우측 꼬리"
+            else:
+                dist = "극단 좌측 꼬리"
+
+        # 로그변환 필요성 판정
+        if abs_skew < 0.5:
+            log_need = "낮음"
+        elif abs_skew < 1.0:
+            log_need = "중간"
+        else:
+            log_need = "높음"
+
+        additional_stats.append({
+            'field': f,
+            'iqr': iqr,
+            'up': up,
+            'down': down,
+            'outlier_count': outlier_count,
+            'outlier_rate': outlier_rate,
+            'skew': skew,
+            'dist': dist,
+            'log_need': log_need
+        })
+
+    additional_df = DataFrame(additional_stats).set_index('field')
+
+    # 결과 병합
+    result = concat([desc, additional_df], axis=1)
+
+    # columns 파라미터가 지정된 경우 해당 컬럼만 필터링
+    if columns is not 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()