apsniper0673-stockutil 0.1.0__tar.gz

apsniper0673_stockutil-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 HyuntaMansei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

apsniper0673_stockutil-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: apsniper0673_stockutil
+Version: 0.1.0
+Summary: My stock utility package
+Author: sniper0673
+Requires-Python: >=3.8
+License-File: LICENSE
+Dynamic: license-file

apsniper0673_stockutil-0.1.0/README.md

@@ -0,0 +1 @@
+# mystockdataprovider

apsniper0673_stockutil-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "apsniper0673_stockutil"
+version = "0.1.0"
+description = "My stock utility package"
+authors = [
+  { name = "sniper0673" }
+]
+requires-python = ">=3.8"
+dependencies = [
+    # "pandas",
+    # "numpy",
+]
+
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

apsniper0673_stockutil-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

apsniper0673_stockutil-0.1.0/src/apsniper0673_stockutil.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: apsniper0673_stockutil
+Version: 0.1.0
+Summary: My stock utility package
+Author: sniper0673
+Requires-Python: >=3.8
+License-File: LICENSE
+Dynamic: license-file

apsniper0673_stockutil-0.1.0/src/apsniper0673_stockutil.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/apsniper0673_stockutil.egg-info/PKG-INFO
+src/apsniper0673_stockutil.egg-info/SOURCES.txt
+src/apsniper0673_stockutil.egg-info/dependency_links.txt
+src/apsniper0673_stockutil.egg-info/top_level.txt
+src/mystockutil/__init__.py
+src/mystockutil/ds.py
+src/mystockutil/etc.py
+src/mystockutil/spreadsheet_manager.py
+src/mystockutil/trader_window_manager.py
+src/mystockutil/type_convert.py
+src/mystockutil/df/format.py
+src/mystockutil/df/type.py
+src/mystockutil/df/voperation.py
+src/mystockutil/logging/__init__.py
+src/mystockutil/logging/logging_setup.py
+src/mystockutil/messenger/__init__.py
+src/mystockutil/messenger/discord/__init__.py
+src/mystockutil/messenger/discord/sender.py
+src/mystockutil/naming/__init__.py
+src/mystockutil/naming/name.py

apsniper0673_stockutil-0.1.0/src/apsniper0673_stockutil.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

apsniper0673_stockutil-0.1.0/src/apsniper0673_stockutil.egg-info/top_level.txt

@@ -0,0 +1 @@
+mystockutil

apsniper0673_stockutil-0.1.0/src/mystockutil/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+__author__ = "sniper0673"

apsniper0673_stockutil-0.1.0/src/mystockutil/df/format.py

@@ -0,0 +1,150 @@
+import os
+import datetime as dt
+
+import pandas as pd
+import numpy as np
+from tabulate import tabulate
+
+from mystockutil.type_convert import convert_numeric_columns
+
+from mystockutil.logging.logging_setup import CustomAdapter, logger as original_logger
+logger = CustomAdapter(logger=original_logger, extra={'prefix': 'format'})
+
+"""데이터프레임을 보여주거나 출력하기 위한 함수들을 모아놓은 모듈입니다."""
+
+zero_decimal_columns = [
+    '매수총액', '매도총액', '매수평균가', '매수액', '매도액', '현매수', '현재가',
+    '평가손익', '실현', '평가', '총평가', '손익', '총손익',  '실현손익', 'TR실현손익', '총실현손익', '미기록손익', 
+    '예수금', 'D+1예수금', 'D+2예수금', 
+    '현예산', '현금', '초기예산', '잔여예산', '현재예산'
+    '포지션사이즈', '총수수료',
+    '가용예산', '투입예산', '예비예산', '현재예산',
+    '수량', '매수수량', '매도수량', '매도가능수량', '매도가능수량_최대',
+    '매수금액', '매도금액', '금액', '평가금액'
+]
+one_decimal_columns = [
+    '평균보유일수', '평균보유', '평균포지션', '발생주기',
+]
+two_decimal_columns = [
+    
+]
+percent_columns = [
+    '수익률', '평균수익률', '추정CAGR', '승률', 'CAGR', '변동률',
+    '매도비중', '매도비중_fluct', '매도비중_return',
+]
+
+EXCEL_PATH = r'./df_execl'
+
+def myprint(*args, **kwargs):
+    """
+    print 함수의 wrapper로, DataFrame이나 dict는 엑셀로 저장하고 출력하며,
+    그 외 값은 일반 print로 출력합니다.
+    """
+    if len(args) == 0:
+        return
+
+    first_arg, *rest_args = args
+
+    # DataFrame 또는 dict인 경우 별도 처리
+    if isinstance(first_arg, pd.DataFrame) or isinstance(first_arg, dict):
+        fixed_order = kwargs.pop('fixed_order', False)
+        print_df(first_arg, fixed_order=fixed_order)
+        if isinstance(first_arg, pd.DataFrame):
+            save_df_to_excel_and_csv(first_arg, EXCEL_PATH)
+    else:
+        print(first_arg)
+
+    # 나머지 인자 재귀 처리
+    if rest_args:
+        myprint(*rest_args, **kwargs)
+
+def save_df_to_excel_and_csv(df: pd.DataFrame, dirpath: str) -> None:
+    """
+    DataFrame을 지정된 디렉토리에 엑셀 파일로 저장합니다.
+    파일명은 현재 날짜와 시간을 포함하여 생성되며,
+    동일한 파일명이 존재할 경우 숫자를 붙여 중복을 방지합니다.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        저장할 데이터프레임
+    dirpath : str
+        엑셀 파일을 저장할 디렉토리 경로
+    """
+    # 디렉토리가 존재하지 않으면 생성
+    os.makedirs(dirpath, exist_ok=True)
+
+    # 현재 날짜와 시간으로 기본 파일명 생성
+    timestamp = dt.datetime.now().strftime('%Y%m%d_%H%M%S')
+    base_filename = f'dataframe_{timestamp}.xlsx'
+    filepath = os.path.join(dirpath, base_filename)
+
+    # 동일한 파일명이 있으면 숫자 추가
+    counter = 1
+    while os.path.exists(filepath):
+        filename_with_counter = f'dataframe_{timestamp}_{counter}.xlsx'
+        filepath = os.path.join(dirpath, filename_with_counter)
+        counter += 1
+
+    # DataFrame을 엑셀로 저장
+    df.to_excel(filepath, index=False)
+    logger.info(f"DataFrame saved to {filepath}")
+    # df.to_csv(filepath.replace('.xlsx', '.csv'), index=False, encoding='utf-8-sig')
+    # logger.info(f"DataFrame saved to {filepath.replace('.xlsx', '.csv')}")
+        
+def print_df(df:pd.DataFrame, fixed_order=False)->None:
+    if isinstance(df, dict):
+        # dict 형태로 들어온 경우 DF로 변환
+        df = pd.DataFrame([df])
+    if fixed_order:
+        print(tabulate(format_df_to_show(df), headers='keys', tablefmt='psql'))
+    else:
+        print(tabulate(prettify(df), headers='keys', tablefmt='psql'))
+
+def prettify(df:pd.DataFrame)->pd.DataFrame:
+    return format_df_to_show(order_df_to_show(df))
+
+def format_df_to_show(df:pd.DataFrame)->pd.DataFrame:
+    df = convert_numeric_columns(df)
+    cols_to_modify = zero_decimal_columns + one_decimal_columns + two_decimal_columns + percent_columns
+    for col in df.columns:
+        if col in zero_decimal_columns:
+            df[col] = df[col].map('{:,.0f}'.format)
+        elif col in one_decimal_columns:
+            df[col] = df[col].map('{:,.1f}'.format)
+        elif col in two_decimal_columns:
+            df[col] = df[col].map('{:,.2f}'.format)
+        elif col in percent_columns or any(x in col for x in ['%', '대비', '수익률']):
+            df[col] = df[col].apply(
+                lambda x: '{:.2%}'.format(x) if isinstance(x, (int, float)) else x
+                )
+            # df[col] = df[col].map('{:.2%}'.format)
+        elif 'cagr' in col.lower():
+            if (df[col] <= 1).all():
+                # 모든 값이 1 이하일 때 → 100 곱해서 소수점 1자리
+                df[col] = (df[col] * 100).map('{:,.1f}%'.format)
+            else:
+                # 그렇지 않으면 → 그냥 소수점 1자리
+                df[col] = df[col].map('{:,.1f}'.format)    
+    return df
+
+def order_df_to_show(df:pd.DataFrame)->pd.DataFrame:
+    first_order_columns = [
+        '종목명', '수량', '매수총액', '평가손익', '실현손익', '수익률'
+    ]
+    second_order_columns = [
+        '매수가', '매수평균가', '매수총액', '매도가', '매도평균가', '매도총액'
+    ]
+    last_order_columns = [
+        '매수일', '매도일', '증권사', '계좌번호'
+    ]
+    existing_columns = df.columns.copy()
+    for cols in [second_order_columns, first_order_columns]:
+        cols_to_move = [c for c in cols if c in existing_columns]
+        cols_to_stay = [c for c in existing_columns if c not in cols]
+        df = df[cols_to_move + cols_to_stay]
+    for cols in [last_order_columns]:
+        cols_to_move = [c for c in cols if c in existing_columns]
+        cols_to_stay = [c for c in existing_columns if c not in cols]
+        df = df[cols_to_stay + cols_to_move]
+    return df

apsniper0673_stockutil-0.1.0/src/mystockutil/df/type.py

@@ -0,0 +1,46 @@
+import pandas as pd
+import numpy as np
+
+def init_df_with_type(
+    df: pd.DataFrame,
+    int_cols: list[str] = None,
+    float_cols: list[str] = None,
+    insert_when_not_exist:bool = True,
+    fill_int_value: int = 0,
+    fill_float_value: float = 0.0
+    ) -> pd.DataFrame:
+    """
+    DataFrame의 특정 열을 지정된 타입으로 초기화합니다.
+    Parameters
+    ----------
+    df : pd.DataFrame
+        초기화할 DataFrame
+    int_cols : list[str], optional
+        정수형으로 초기화할 열의 리스트, 기본값은 None
+    float_cols : list[str], optional
+        실수형으로 초기화할 열의 리스트, 기본값은 None
+    insert_when_not_exist : bool, optional
+        지정된 열이 DataFrame에 없을 경우 새로 추가할지 여부, 기본값은 True
+    """
+    df = df.copy()  # 원본 DataFrame을 변경하지 않도록 복사
+    if int_cols is None:
+        int_cols = []
+    if float_cols is None:
+        float_cols = []
+    # 정수형 열 초기화
+    for col in int_cols:
+        if col not in df.columns:
+            if insert_when_not_exist:
+                df[col] = 0
+            else:
+                continue
+        df[col] = df[col].fillna(fill_int_value).astype(int)
+    # 실수형 열 초기화
+    for col in float_cols:
+        if col not in df.columns:
+            if insert_when_not_exist:
+                df[col] = 0.0
+            else:
+                continue
+        df[col] = df[col].fillna(fill_float_value).astype(float)
+    return df

apsniper0673_stockutil-0.1.0/src/mystockutil/df/voperation.py

@@ -0,0 +1,56 @@
+import pandas as pd
+from pandas import Series
+import numpy as np
+from typing import List
+
+"""
+데이터프레임의 벡터화된 연산들을 정의한 모듈입니다.
+df는 '일자'와 '종목코드'의 MultiIndex를 가지고 있는 경우를 Default로 가정합니다."""
+
+def count(df:pd.DataFrame, reset:Series, reset_value:int=1, counting:Series=None, group_by:bool=True, groups:List[str]=['종목코드'])->pd.Series:
+    """
+    reset이 True일 때, 카운트는 reset_value로 초기화
+    False일 때, 카운트에 counting을 더함"""
+    df = df.copy()
+    if group_by and groups == ['종목코드']:
+        if counting is None:
+            # df와 동일한 길이의 1로 이루어진 Series를 만듭니다.
+            counting = Series(1, index=df.index)
+        return _count_default(df=df, reset=reset, reset_value=reset_value, counting=counting)
+    else:
+        raise NotImplementedError("Not implemented yet.")
+def _count_default(df:pd.DataFrame, reset:Series, reset_value:int, counting:Series)->pd.Series:
+    """
+    종목코드별로 카운트를 계산합니다."""
+    df['counting'] = counting
+    df['reset'] = reset
+    df['카운트그룹'] = df.groupby('종목코드')['reset'].cumsum() # 카운트그룹은 0부터 시작함
+    df['카운트'] = df.groupby(['종목코드', '카운트그룹'])['counting'].cumsum()
+    return df['카운트']
+
+def switch(df:pd.DataFrame, on:Series, off:Series, default_bool:bool=False, direction:bool=True, group_by:bool=True, groups:List[str]=['종목코드'])->pd.Series:
+    """
+    switch가 on인 경우에는 True값을 off가 될 때까지 유지
+    제일 초기값은 False가 Default
+    direction이 True면 ffll, False면 bfill
+    """
+    df = df.copy()
+    if group_by and groups == ['종목코드']:
+        return _switch_default(df=df, on=on, off=off, default_bool=default_bool, direction=direction)
+    else:
+        raise NotImplementedError("Not implemented yet.")
+
+def _switch_default(df:pd.DataFrame, on:Series, off:Series, default_bool:bool, direction:bool)->pd.Series:
+    """
+    종목코드별로 스위치를 계산합니다."""
+    df['on'] = on
+    df['off'] = off
+    df['switch'] = np.nan
+    df['switch'] = df['switch'].mask(df['on'], True)
+    df['switch'] = df['switch'].mask(df['off'], False)
+    if direction:
+        df['switch'] = df.groupby('종목코드')['switch'].ffill()
+    else:
+        df['switch'] = df.groupby('종목코드')['switch'].bfill()
+    df['switch'] = df['switch'].fillna(default_bool)
+    return df['switch'].astype(bool)

apsniper0673_stockutil-0.1.0/src/mystockutil/ds.py

@@ -0,0 +1,2 @@
+def make_dict(**kwargs):
+    return kwargs

apsniper0673_stockutil-0.1.0/src/mystockutil/etc.py

@@ -0,0 +1,260 @@
+from pathlib import Path
+import ipynbname
+import pandas as pd
+import numpy as np
+
+
+from mystockutil.logging.logging_setup import CustomAdapter, logger as original_logger
+logger = CustomAdapter(original_logger, {'prefix': 'Utility'})
+
+import inspect
+from pathlib import Path
+def get_project_root(marker: str = "pyproject.toml") -> Path:
+    """
+    이 함수를 호출한 파일 기준으로 상위 디렉토리에서 marker (예: pyproject.toml)를 찾는다.
+    """
+    # 호출한 파일의 경로
+    caller_path = Path(inspect.stack()[1].filename).resolve()
+
+    for parent in caller_path.parents:
+        if (parent / marker).exists():
+            return parent
+
+    raise RuntimeError(f"Cannot find project root containing {marker} from {caller_path}")
+
+def get_base_dir(sub_dirs=[]):
+    """
+    현재 실행 중인 파일의 디렉토리를 기준으로 base_dir을 설정합니다.
+    Jupyter Notebook과 스크립트 모두에서 동작합니다.
+    """
+    try:
+        # Jupyter Notebook 환경에서 현재 노트북의 경로를 가져옵니다.
+        notebook_path = ipynbname.path()
+        base_dir = Path(notebook_path).parent.joinpath(*sub_dirs)
+        return base_dir
+    except (FileNotFoundError, ImportError):
+        # 스크립트 실행 환경 또는 ipynbname 사용 불가 시
+        try:
+            # 스크립트 파일의 경로를 가져옵니다.
+            script_path = Path(__file__).resolve()
+            base_dir = script_path.parent.parent.joinpath(*sub_dirs)
+            return base_dir
+        except NameError:
+            # __file__이 정의되지 않은 경우 (예: 대화형 환경)
+            # 현재 작업 디렉토리를 기준으로 설정합니다.
+            base_dir = Path.cwd().joinpath('table', *sub_dirs)
+            return base_dir
+
+def remove_unnecessary_symbols(df:pd.DataFrame) -> pd.DataFrame:
+    """
+    불필요한 종목 제거
+    df - 종목 데이터프레임, 종목코드와 종목명이 포함되어 있어야 함
+    df - index가 설정되어 있지 않아야 함
+    """
+    # 
+    columns = df.columns
+    if '시장ID' in columns:
+        new_df = df.copy()
+        new_df = new_df[
+        ~new_df['종목명'].str.contains(r'\d+호$') & 
+        ~new_df['종목명'].str.contains('스팩') &
+        new_df['종목코드'].str.endswith('0') &
+        new_df['시장ID'].str.contains('STK|KSQ')
+        ]
+    else:
+        new_df = df.reset_index(drop=False)
+        new_df = new_df[
+        ~new_df['종목명'].str.contains(r'\d+호$') & 
+        ~new_df['종목명'].str.contains('스팩') &
+        new_df['종목코드'].str.endswith('0')
+        ]
+    return new_df
+
+# 현재 시장의 상하한가 계산
+def calculate_limit_current(price: pd.Series, side: str, after: bool = False) -> int:
+    """
+    side: 'buy' or 'sell'
+    """
+    if side == 'buy':
+        return calculate_upper_limit(price, after)
+    else:
+        return calculate_lower_limit(price, after)
+def calculate_upper_limit(price: pd.Series, after: bool = False) -> int:
+    if not after:
+        # 장중 상한가 계산
+        return round_down_price_with_series_current(price * 1.3)
+    else:
+        # 시간외 상한가 계산
+        return round_down_price_with_series_current(price * 1.1)
+def calculate_lower_limit(price: pd.Series, after: bool = False) -> int:
+    if not after:
+        # 장중 하한가 계산
+        return round_up_price_with_series_current(price * 0.7)
+    else:
+        # 시간외 하한가 계산
+        return round_up_price_with_series_current(price * 0.9)
+
+# 가격 올림처리
+def round_up_price_with_series_current(prices: pd.Series) -> pd.Series:
+    # 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 2000, 5000, 20000, 50000, 200000, 500000, float('inf')]
+    steps = [1, 5, 10, 50, 100, 500, 1000]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 올림 처리
+    rounded_prices = ((np.ceil(prices) + step_series - 0.1) // step_series) * step_series
+    return rounded_prices
+def round_up_price_with_series_kospi_current(prices: pd.Series) -> pd.Series:
+    return round_up_price_with_series_current(prices)
+def round_up_price_with_series_kosdaq_current(prices: pd.Series) -> pd.Series:
+    return round_up_price_with_series_current(prices)
+
+def round_up_price_with_series_kospi_old(prices: pd.Series) -> pd.Series:
+    """
+    과거 Kospi 시장의 가격 구간에 따른 올림 반올림 처리.
+    """
+    # 과거 Kospi 시장에서 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 1000, 5000, 10000, 50000, 100000, 500000, float('inf')]
+    steps = [1, 5, 10, 50, 100, 500, 1000]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 올림 처리
+    rounded_prices = ((np.ceil(prices) + step_series - 0.1) // step_series) * step_series
+    return rounded_prices
+def round_up_price_with_series_kosdaq_old(prices: pd.Series) -> pd.Series:
+    """
+    과거 Kosdaq 시장의 가격 구간에 따른 올림 반올림 처리.
+    """
+    # 과거 Kosdaq 시장에서 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 1000, 5000, 10000, 50000, float('inf')]
+    steps = [1, 5, 10, 50, 100]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 올림 처리
+    rounded_prices = ((np.ceil(prices) + step_series - 0.1) // step_series) * step_series
+    return rounded_prices
+
+# 가격 내림처리
+def round_down_price_with_series_current(prices:pd.Series)->pd.Series:
+    # 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 2000, 5000, 20000, 50000, 200000, 500000, float('inf')]
+    steps = [1, 5, 10, 50, 100, 500, 1000]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 반올림 (내림)
+    rounded_prices = (prices // step_series) * step_series
+    return rounded_prices
+def round_down_price_with_series_kospi_current(prices:pd.Series)->pd.Series:
+    return round_down_price_with_series_current(prices)
+def round_down_price_with_series_kosdaq_current(prices:pd.Series)->pd.Series:
+    return round_down_price_with_series_current(prices)
+
+def round_down_price_with_series_kospi_old(prices:pd.Series)->pd.Series:
+    """
+    과거 Kospi 시장의 가격 구간에 따른 내림 반올림 처리.
+    """
+    # 과거 Kospi 시장에서 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 1000, 5000, 10000, 50000, 100000, 500000, float('inf')]
+    steps = [1, 5, 10, 50, 100, 500, 1000]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 반올림 (내림)
+    rounded_prices = (prices // step_series) * step_series
+    return rounded_prices
+def round_down_price_with_series_kosdaq_old(prices:pd.Series)->pd.Series:
+    """
+    과거 Kosdaq 시장의 가격 구간에 따른 내림 반올림 처리.
+    """
+    # 과거 Kosdaq 시장에서 각 구간에 해당하는 step 값을 정의
+    bins = [-float('inf'), 1000, 5000, 10000, 50000, float('inf')]
+    steps = [1, 5, 10, 50, 100]
+    
+    # pd.cut을 사용해 각 price에 대해 적절한 step 값을 할당
+    step_series = pd.cut(prices, bins=bins, labels=steps, right=False).astype(int)
+    
+    # 각 price를 step에 맞춰 반올림 (내림)
+    rounded_prices = (prices // step_series) * step_series
+    return rounded_prices
+
+# float 값을 시리즈로 변환하여 계산
+def round_up_price_current(price:float)->int:
+    price_as_series = pd.Series(price)
+    return int(round_up_price_with_series_current(price_as_series)[0])
+def round_down_price_current(price:float)->int:
+    price_as_series = pd.Series(price)
+    return int(round_down_price_with_series_current(price_as_series)[0])
+
+# 하나의 값에 대한 계산(위의 함수를 이용하지 않음)
+def round_down_price(price, market:str='kospi', when:str='current'):
+    """
+    2023.1.25일부로 수정됨.
+    """
+    if isinstance(price, (pd.DataFrame, pd.Series)):
+        return price.apply(round_down_price, market=market, when=when)
+    price_unit = get_price_unit(price, market, when)
+    return (price // price_unit) * price_unit
+def round_up_price(price, market:str='kospi', when:str='current'):
+    if isinstance(price, (pd.DataFrame, pd.Series)):
+        return price.apply(round_up_price)
+    price_unit = get_price_unit(price, market, when)
+    return ((np.ceil(price) + price_unit - 0.1) // price_unit) * price_unit
+def get_price_unit(price, market, when) -> int:
+    """
+    2023.1.25일부로 수정됨.
+    """
+    if when == 'current':
+        if price < 2000:
+            step = 1  # 2,000원 미만일 때 1원 단위
+        elif price < 5000:
+            step = 5  # 2,000원 이상 5,000원 미만일 때 5원 단위
+        elif price < 20000:
+            step = 10  # 5,000원 이상 20,000원 미만일 때 10원 단위
+        elif price < 50000:
+            step = 50  # 20,000원 이상 50,000원 미만일 때 50원 단위
+        elif price < 200000:
+            step = 100  # 50,000원 이상 200,000원 미만일 때 100원 단위
+        elif price < 500000:
+            step = 500  # 200,000원 이상 500,000원 미만일 때 500원 단위
+        else:
+            step = 1000  # 500,000원 이상일 때 1,000원 단위
+            
+    elif market.lower() == 'kospi' or market == '코스피':
+        if price < 1000:
+            step = 1  # 1,000원 미만일 때 1원 단위
+        elif price < 5000:
+            step = 5  # 1,000원 이상 5,000원 미만일 때 5원 단위
+        elif price < 10000:
+            step = 10  # 5,000원 이상 10,000원 미만일 때 10원 단위
+        elif price < 50000:
+            step = 50  # 20,000원 이상 50,000원 미만일 때 50원 단위
+        elif price < 100000:
+            step = 100  # 50,000원 이상 200,000원 미만일 때 100원 단위
+        elif price < 500000:
+            step = 500  # 200,000원 이상 500,000원 미만일 때 500원 단위
+        else:
+            step = 1000  # 500,000원 이상일 때 1,000원 단위
+    else: # 과거 Kosdaq인 경우
+        if price < 1000:
+            step = 1  # 1,000원 미만일 때 1원 단위
+        elif price < 5000:
+            step = 5  # 1,000원 이상 5,000원 미만일 때 5원 단위
+        elif price < 10000:
+            step = 10  # 5,000원 이상 10,000원 미만일 때 10원 단위
+        elif price < 50000:
+            step = 50  # 20,000원 이상 50,000원 미만일 때 50원 단위
+        else:
+            step = 100  # 50,000원 이상 200,000원 미만일 때 100원 단위
+    return step
+
+if __name__ == '__main__':
+    print(df)

apsniper0673_stockutil-0.1.0/src/mystockutil/logging/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+__author__ = "Hyuntamansei"

apsniper0673_stockutil-0.1.0/src/mystockutil/logging/logging_setup.py

@@ -0,0 +1,36 @@
+import logging
+    
+# 로거 생성
+logger = logging.getLogger('my_logger')
+logger.setLevel(logging.DEBUG)
+
+# 중복 핸들러 방지
+if logger.hasHandlers():
+    logger.handlers.clear()
+
+# 콘솔 핸들러 생성
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+
+# 파일 핸들러 생성
+file_handler = logging.FileHandler('stock.log')
+file_handler.setLevel(logging.DEBUG)
+
+# 포맷 설정
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+formatter = logging.Formatter('%(levelname)s - %(message)s - %(asctime)s')
+console_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
+
+# 핸들러 추가
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+# LoggerAdapter 사용하여 파일별 접두어 설정
+class CustomAdapter(logging.LoggerAdapter):
+    def process(self, msg, kwargs):
+        return '[%s] %s' % (self.extra['prefix'], msg), kwargs
+
+# 각 파일마다 'prefix'를 다르게 설정
+def get_custom_logger(prefix):
+    return CustomAdapter(logger, {'prefix': prefix})

apsniper0673_stockutil-0.1.0/src/mystockutil/messenger/discord/sender.py

@@ -0,0 +1,44 @@
+import requests
+
+class DiscordSender:
+    def __init__(self, webhook_url):
+        self.webhook_url = webhook_url
+
+    def send(self, message):
+        requests.post(self.webhook_url, json={"content": message})
+
+# 황금비 대표        
+gr_sender = DiscordSender('https://discord.com/api/webhooks/1347084901844779018/sqgHY3P14seiIPXd15-AIxIftRdfzFV9Or2fYtBB1XevLevpPweNJm9H5cdIW0HcKwj1')
+
+# 황금비 개별
+gr_entry_zero = DiscordSender('https://discord.com/api/webhooks/1362630337888260116/NPTk3V8wOKZ8sjS-g0o-4OSZgy7CFib83furIDONAomphFZGS9sdYwy6CaxLSkd0J2_s')
+gr_entry_one = DiscordSender('https://discord.com/api/webhooks/1362666742978973796/uW_RoUBRSgwryY8L0QQy_W7YH6VjTuvyy8-iUgKJkShlYWaj4xz_G9BEnxN5axUFtO9i')
+gr_entry_two = DiscordSender('https://discord.com/api/webhooks/1362666785362411610/oBK59j4o4_IJ_3Tuwny5vJEgZHWOfpRTBuTwt-sCSDH2GHEigWEWkIE3hZPUpJ9TgZlb')
+gr_entry_three = DiscordSender('https://discord.com/api/webhooks/1362666807101751416/h5e4NoKMcQTClpFhQL10sg5GR-L-QQVBZj0pKTRTwfUZNq1vwVu4i9rJLLgaW7HhEog0')
+gr_entry_four = DiscordSender('https://discord.com/api/webhooks/1362666830669287465/0WbVPFOYHfZzx-eBzyJ-nfiKF5iIjtiVHClocAT2wzKCeFtkB9yrg3mAMc10Wc9PqlUw')
+gr_entry_five = DiscordSender('https://discord.com/api/webhooks/1362666854987862066/aFSajyALHttWjLabAl6UBebD7doiyOSj3gIFcqFGCaFiq6imBVsGOE0NG15jtuBfRKVo')
+gr_entry_hf = DiscordSender('https://discord.com/api/webhooks/1354984972661952673/vIiCfFlh8gNNMtdyenZr_s6d_ENU37Bgab5y6bR_49i-XJ04zCU2HUPiDb_F-Rx0E2RN')
+
+gr_exit_zero = DiscordSender('https://discord.com/api/webhooks/1374232079012986960/BaT5zEcIUrCDYzFfHpgS1GPhZFNKdLfunpY8gbIaja4K3QsdU7sdySJWD2aGpfpwalZi')
+gr_exit_one = DiscordSender('https://discord.com/api/webhooks/1374238305100627998/oC2dpWdkUDvgz5g0glB-SJmjgvrXINi73cNpHHYEo0VW3jhsGxMswBohsqy84LTlRFnZ')
+gr_exit_two = DiscordSender('https://discord.com/api/webhooks/1374238355478548601/-RK0X7wHTC7OAKBAnXCb4Sa46F1UutdmJhrTiGBUDh1ypLpEj6RmuA1m9pDH8R4X0jOj')
+gr_exit_three = DiscordSender('https://discord.com/api/webhooks/1374238411682222181/A0F2OWzdYonp-1-N6B1mfXlajhLelL8sTlvRFlAnHCohfgL_yViPyfe6k322H3UENnsf')
+gr_exit_four = DiscordSender('https://discord.com/api/webhooks/1374238464278528020/IMO8inC-CEOLweQg-AfyeHK-4Cj1ynXqaWjVpVxoqRet4NNG872toy9m_ZvUjK1IOsOI')
+gr_exit_five = DiscordSender('https://discord.com/api/webhooks/1374238519794340004/ptC2C2LSiTeUiktTo2-O1ByBegM9IOFs2AcIbdW1w-1MgUh6cZ6jlEyKxQy_xTHNT0ky')
+
+
+# Scheduler sender
+ms_sender = DiscordSender('https://discord.com/api/webhooks/1347085128509165579/Tqo-NevMGrQ5HZXjaAVfMk4t5-OW2C_zNzCVeT9z0-HwQwvJcov0u2qKxNkdTCKaghrf')
+ss_sender = DiscordSender('https://discord.com/api/webhooks/1353572795178549288/GLrhkNAHMbmlMrpf2JLQ_7Zuns-fHthmUT_Vq7UnCsFU3keEDywxmci2yyPeXfLWVnhV')
+
+# gr_two = DiscordSender('https://discord.com/api/webhooks/1354984967373066373/0NLNQJ_7UIoV-yt53TIIw9ZyGleHgkbTnFzJ8v_JdXdJUfLEQgqzCizSoV4F9MhA3pPi')
+# gr_three = DiscordSender('https://discord.com/api/webhooks/1357226724496244837/9GrTKJjgUD8bGd8uxEWc-FBVV_iZ6-SGYj40b3b8H3EE7YsrLkk3jh7BOn7_wIR6B7R9')
+# gr_four = DiscordSender('https://discord.com/api/webhooks/1359768724751650847/ykUDJIMzNoI1W98p4cVBoHz4kDFqXmsLFf_UmSS2d5muHDINyyipWTqTUswOyyP1Ev9C')
+# gr_five = DiscordSender('https://discord.com/api/webhooks/1359768729948258354/seFMt3APXQY4HE6tjWmwhAig5HAlyxlAXd8Ayjy8gIFLD_SE6btxJD9yhBkdeu4U_JFT')
+# gr_hf = DiscordSender('https://discord.com/api/webhooks/1354984972661952673/vIiCfFlh8gNNMtdyenZr_s6d_ENU37Bgab5y6bR_49i-XJ04zCU2HUPiDb_F-Rx0E2RN')
+
+if __name__ == '__main__':
+    senders = [gr_sender, ms_sender]
+    for sender in senders:
+        sender.send("Hello, World!")
+        sender.send("This is a test message.")

apsniper0673_stockutil-0.1.0/src/mystockutil/naming/__init__.py

@@ -0,0 +1 @@
+from .name import Name

apsniper0673_stockutil-0.1.0/src/mystockutil/naming/name.py

@@ -0,0 +1,25 @@
+import re
+
+class Name:
+    """클래스 이름을 자동으로 생성하는 클래스
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        # __init__가 후행 호출되는 경우에도 작동할 수 있도록 설계
+        if not hasattr(self, '_comment'):
+            self._comment:str = None
+        if not hasattr(self, 'version'):
+            self.version:str = None
+    @property
+    def name(self):
+        """comment에서 최신 버전을 찾아 name을 리턴"""
+        if hasattr(self, '_comment'):
+            versions = re.findall(r'v\d+\.\d+', self._comment)  # 모든 vX.XX 패턴 찾기
+        else:
+            versions = []
+        latest_version = versions[-1] if versions else "v0.00"  # 가장 마지막 버전 선택
+        if hasattr(self, 'version'):
+            self.version = latest_version
+        if hasattr(self, '_name'):
+            return f'{self._name}{latest_version}'
+        return f'{self.__class__.__name__}{latest_version}'

apsniper0673_stockutil-0.1.0/src/mystockutil/spreadsheet_manager.py

@@ -0,0 +1,52 @@
+import pandas as pd
+import gspread
+from gspread_dataframe import set_with_dataframe, get_as_dataframe
+
+class SpreadsheetManager:
+    def __init__(self, creds_json_path: str, sheet_id: str):
+        self.creds_json_path = creds_json_path
+        self.sheet_id = sheet_id
+        self.client = self._authorize()
+
+    def _authorize(self):
+        scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
+        creds = gspread.service_account(filename=self.creds_json_path, scopes=scope)
+        return creds
+
+    def upload_df(self, df: pd.DataFrame, worksheet_name: str, index: bool = True) -> None:
+        spreadsheet = self.client.open_by_key(self.sheet_id)
+        worksheet = self._get_or_create_worksheet(spreadsheet, worksheet_name)
+        worksheet.clear()
+        set_with_dataframe(worksheet, df, include_index=index)
+
+    def download_df(self, worksheet_name: str) -> pd.DataFrame:
+        spreadsheet = self.client.open_by_key(self.sheet_id)
+        worksheet = self._get_or_create_worksheet(spreadsheet, worksheet_name)
+        return get_as_dataframe(worksheet, header=0, index_col=None, dtype=str)
+
+    def _get_or_create_worksheet(self, spreadsheet, worksheet_name: str):
+        try:
+            return spreadsheet.worksheet(worksheet_name)
+        except gspread.WorksheetNotFound:
+            return spreadsheet.add_worksheet(title=worksheet_name, rows="100", cols="20")
+        
+def test():
+    creds_json_path = r'./credentials/vertical-album-400707-49b25aaf32d5.json'
+    sheet_id = "1iK7UY7g_fSRSAOpIEYrFR41p_qK68LhkcIfqr7NUxug"
+    sheet_manager = SpreadsheetManager(creds_json_path, sheet_id)
+
+    # Test uploading a DataFrame
+    df = pd.DataFrame({
+        'A': [1, 2, 3],
+        'B': [4, 5, 6]
+    })
+    sheet_manager.upload_df(df, "TestWorksheet")
+
+    # Test downloading a DataFrame
+    downloaded_df = sheet_manager.download_df("TestWorksheet")
+    print_df(downloaded_df)
+
+if __name__ == "__main__":
+    from utility.df.format import print_df
+    test()
+    print("SpreadsheetManager test completed successfully.")

apsniper0673_stockutil-0.1.0/src/mystockutil/trader_window_manager.py

@@ -0,0 +1,129 @@
+import psutil
+import win32gui
+import win32con
+import win32process
+import win32api
+
+# 마지막 모니터의 작업 영역 (작업표시줄 제외)
+def get_last_monitor_work_area():
+    monitors = win32api.EnumDisplayMonitors()
+    last_monitor = monitors[-1][0]
+    info = win32api.GetMonitorInfo(last_monitor)
+    return info['Work']  # (left, top, right, bottom)
+
+# 마지막 모니터의 전체 해상도 (작업표시줄 포함)
+def get_last_monitor_resolution():
+    monitors = win32api.EnumDisplayMonitors()
+    last_monitor = monitors[-1][0]
+    info = win32api.GetMonitorInfo(last_monitor)
+    mon_left, mon_top, mon_right, mon_bottom = info['Monitor']
+    return mon_right - mon_left, mon_bottom - mon_top
+
+# 실제 표시되는 콘솔 창의 HWND 반환
+def get_real_visible_hwnd_by_pid(pid):
+    hwnds = []
+    def callback(hwnd, hwnds):
+        _, found_pid = win32process.GetWindowThreadProcessId(hwnd)
+        class_name = win32gui.GetClassName(hwnd)
+        if found_pid == pid and win32gui.IsWindowVisible(hwnd):
+            if class_name == "PseudoConsoleWindow":
+                parent = win32gui.GetParent(hwnd)
+                if parent and win32gui.IsWindowVisible(parent):
+                    hwnds.append(parent)
+            else:
+                hwnds.append(hwnd)
+        return True
+    win32gui.EnumWindows(callback, hwnds)
+    return hwnds[0] if hwnds else None
+
+# 창 위치 이동 (프레임 보정 포함)
+def set_window_pos(hwnd, x, y, width, height, is_4k=False):
+    if hwnd and win32gui.IsWindow(hwnd):
+        # 마진 조정
+        if is_4k:
+            horizontal_margin = -12
+            vertical_margin = -14
+        else:
+            horizontal_margin = -6
+            vertical_margin = -8
+
+        x += horizontal_margin
+        y += vertical_margin
+        width -= horizontal_margin * 2
+        height -= vertical_margin
+
+        win32gui.ShowWindow(hwnd, win32con.SW_RESTORE)
+        win32gui.SetWindowPos(hwnd, None, x, y, width, height,
+                              win32con.SWP_NOZORDER | win32con.SWP_SHOWWINDOW)
+
+# 전체 정렬 로직
+def adjust_windows_by_recent_procs():
+    # 작업 가능한 영역 (창 위치 기준)
+    left, top, right, bottom = get_last_monitor_work_area()
+    screen_w = right - left
+    screen_h = bottom - top
+
+    # 전체 해상도 기준 4K 판별
+    mon_w, mon_h = get_last_monitor_resolution()
+    is_4k = mon_w * mon_h >= 8000000
+    is_portrait = screen_h > screen_w
+
+    left_w = screen_w // 2
+    right_w = screen_w - left_w
+    top_h = screen_h // 2
+    bottom_h = screen_h - top_h
+
+    # 위치 설정
+    if is_4k:
+        if is_portrait:
+            positions = [
+                (left, top, screen_w, top_h),
+                (left, top, left_w, top_h),
+                (left + left_w, top, right_w, top_h),
+                (left, top + top_h, screen_w, bottom_h),
+                (left, top + top_h, left_w, bottom_h),
+                (left + left_w, top + top_h, right_w, bottom_h),
+            ]
+        else:
+            positions = [
+                (left, top, left_w, screen_h),
+                (left, top, left_w, top_h),
+                (left, top + top_h, left_w, bottom_h),
+                (left + left_w, top, right_w, screen_h),
+                (left + left_w, top, right_w, top_h),
+                (left + left_w, top + top_h, right_w, bottom_h),
+            ]
+    else:
+        positions = [
+                (left, top, left_w, screen_h),
+                (left, top, left_w, top_h),
+                (left, top + top_h, left_w, bottom_h),
+                (left + left_w, top, right_w, screen_h),
+                (left + left_w, top, right_w, top_h),
+                (left + left_w, top + top_h, right_w, bottom_h),
+        ]
+
+    # 현재 Python을 실행한 cmd.exe 제외
+    parent_pid = psutil.Process().ppid()
+
+    procs = [
+        p for p in psutil.process_iter(['pid', 'name', 'create_time'])
+        if p.info['name'] == 'cmd.exe' and p.info['pid'] != parent_pid
+    ]
+
+    procs.sort(key=lambda p: p.info['create_time'], reverse=True)
+    selected_procs = procs[:6]
+    selected_procs.reverse()
+
+    for i, proc in enumerate(selected_procs):
+        hwnd = get_real_visible_hwnd_by_pid(proc.info['pid'])
+        if hwnd:
+            x, y, w, h = positions[i]
+            print(f"[INFO] Moving PID {proc.info['pid']} to ({x}, {y}, {w}, {h})")
+            set_window_pos(hwnd, x, y, w, h, is_4k=is_4k)
+        else:
+            print(f"[WARN] No visible HWND found for PID {proc.info['pid']}")
+
+# 실행
+if __name__ == "__main__":
+    adjust_windows_by_recent_procs()

apsniper0673_stockutil-0.1.0/src/mystockutil/type_convert.py

@@ -0,0 +1,121 @@
+import re
+
+def extract_clean_int(s: str) -> int:
+    """
+    문자열에서 숫자와 쉼표를 추출하여 정수로 변환합니다.
+    처리할 수 없는 경우 0을 반환합니다."""
+    if not isinstance(s, str):
+        return s
+    # 부호 포함 숫자 패턴: + 또는 -가 있을 수 있고, 그 뒤에 숫자와 쉼표
+    match = re.search(r'[-+]?\d[\d,]*', s)
+    if match:
+        num_str = match.group().replace(',', '')  # 쉼표 제거
+        return int(num_str)
+    return 0
+
+import pandas as pd
+import numpy as np
+import re
+
+def clean_numeric_string(val: str, percent_mode='float') -> float:
+    """
+    Cleans and extracts numeric values from strings.
+    Handles negative values, commas, backslashes, currency symbols, and percentages.
+    """
+    if pd.isna(val):
+        return val
+
+    val = str(val).strip()
+    val = val.replace('\\', '').replace(',', '')
+
+    # Handle percentage
+    if '%' in val:
+        val = val.replace('%', '')
+        try:
+            val = float(val)
+            return val / 100 if percent_mode == 'float' else val
+        except ValueError:
+            return np.nan
+
+    # Remove all non-numeric characters except digits, minus, and dot
+    val = re.sub(r'[^\d\.-]', '', val)
+    try:
+        return float(val)
+    except ValueError:
+        return np.nan
+
+int_cols = []
+float_cols = []
+date_cols = []
+string_cols = [
+    '종목코드', 
+]
+def convert_numeric_columns(
+    df: pd.DataFrame,
+    force_int_cols=None,
+    force_float_cols=None,
+    force_date_cols=None,
+    force_string_cols=None,
+    nan_policy='keep',       # 'keep', 'zero', 'drop'
+    percent_mode='float'     # 'float' → 0.724, 'raw' → 72.4
+) -> pd.DataFrame:
+    force_int_cols = set(force_int_cols or int_cols)
+    force_float_cols = set(force_float_cols or float_cols)
+    force_date_cols = set(force_date_cols or date_cols)
+    force_string_cols = set(force_string_cols or string_cols)
+
+    result_df = df.copy()
+
+    for col in result_df.columns:
+        series = result_df[col]
+
+        # Skip string columns
+        if col in force_string_cols:
+            result_df[col] = series.astype(str)
+            continue
+        # Step 1: Date columns
+        if col in force_date_cols:
+            result_df[col] = pd.to_datetime(series, errors='coerce')
+            continue
+
+        # Step 2: Numeric-like string cleaning
+        if col in force_int_cols or col in force_float_cols:
+            cleaned = series.apply(lambda x: clean_numeric_string(x, percent_mode=percent_mode))
+        else:
+            # Try detecting numeric-like columns (basic heuristic on sample)
+            sample = series.dropna().astype(str).head(10)
+            if all(re.fullmatch(r'\d{4}[./-]\d{2}[./-]\d{2}', x) for x in sample):
+                continue  # 완전한 날짜 패턴이면 스킵
+            
+            if all(re.search(r'[\d₩%,\\]', x) for x in sample):
+                cleaned = series.apply(lambda x: clean_numeric_string(x, percent_mode=percent_mode))
+            else:
+                continue  # skip non-numeric columns
+
+        # Step 3: NaN policy
+        if nan_policy == 'zero':
+            cleaned = cleaned.fillna(0)
+        elif nan_policy == 'drop':
+            cleaned = cleaned.dropna()
+
+        # Step 4: Type decision
+        if col in force_int_cols:
+            result_df[col] = cleaned.astype('Int64')
+        elif col in force_float_cols:
+            result_df[col] = cleaned.astype(float)
+        else:
+            non_na = cleaned.dropna()
+
+            # 소수점 없는 float인지 확인 (정수로 안전하게 변환 가능한지)
+            is_integral = non_na.apply(lambda x: float(x).is_integer()).all()
+            if is_integral:
+                result_df[col] = cleaned.astype('Int64')
+            else:
+                result_df[col] = cleaned.astype(float)
+
+            # if np.allclose(non_na, non_na.astype(int)):
+            #     result_df[col] = cleaned.astype('Int64')
+            # else:
+            #     result_df[col] = cleaned.astype(float)
+
+    return result_df