main_file.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 데이터 로드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #  버전 설치\n",
    "# !pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Importing the dtw module. When using in academic works please cite:\n",
      "  T. Giorgino. Computing and Visualizing Dynamic Time Warping Alignments in R: The dtw Package.\n",
      "  J. Stat. Soft., doi:10.18637/jss.v031.i07.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import asyncio\n",
    "import shutil\n",
    "import pandas as pd\n",
    "import pickle\n",
    "from pytz import timezone\n",
    "from datetime import datetime,timedelta\n",
    "import nest_asyncio\n",
    "from utils.api_set import APIClient\n",
    "import utils.utils as utils\n",
    "import utils.formatting as formatting\n",
    "import models.crawling.trend as trend \n",
    "from models.crawling.collect_keywords import collect_keywords\n",
    "from models.crawling.google_trend import collect_rising_keywords\n",
    "from models.naver.news import main_news \n",
    "from models.anaysis import execute_analysis , process_results ,process_results_month"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. API설정"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# API 설정\n",
    "BASE_URL = utils.get_secret(\"BASE_URL\")\n",
    "CUSTOMER_ID = utils.get_secret(\"CUSTOMER_ID\")\n",
    "API_KEY = utils.get_secret(\"API_KEY\")\n",
    "SECRET_KEY = utils.get_secret(\"SECRET_KEY\")\n",
    "URI = utils.get_secret(\"URI\")\n",
    "METHOD = utils.get_secret(\"METHOD\")\n",
    "# API 클라이언트 인스턴스 생성\n",
    "api_client = APIClient(BASE_URL, CUSTOMER_ID, API_KEY, SECRET_KEY,URI,METHOD)\n",
    "# 키 로드\n",
    "keywords_data = utils.load_keywords('main_keyword.json')\n",
    "\n",
    "# 오늘의 날짜 가져오기\n",
    "formatted_today, day = utils.get_today_date()\n",
    "\n",
    "\n",
    "utils.make_directory('./data')\n",
    "utils.make_directory('./data/rl_srch')\n",
    "utils.make_directory(f'./data/rl_srch/{day}')  # 키워드별 연관검색어 리스트 저장\n",
    "\n",
    "# 검색어 리스트와 결과 저장 경로 설정\n",
    "srch_keyword = ['keyword_final']  \n",
    "save_path = './data/rl_srch/'  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 연관검색어 수집"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unexpected response structure for keyword '세금': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '외국인순매수': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '미국주식': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '달러환율': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '개인연금': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '채권': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '조각투자': {'code': 429, 'message': 'Too Many Requests'}\n",
      "Unexpected response structure for keyword '건강보험': {'code': 429, 'message': 'Too Many Requests'}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "nest_asyncio.apply()\n",
    "\n",
    "async def main(srch_keyword, day):\n",
    "    # 오늘 날짜로 폴더 경로 생성\n",
    "    folder_path = './data/rl_srch/' + datetime.now().strftime('%y%m%d')\n",
    "    file_path = f\"{folder_path}/collected_keywords.csv\"\n",
    "    \n",
    "    # 폴더가 존재하는지 확인\n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "    \n",
    "    # 파일이 존재하는지 확인\n",
    "    if os.path.isfile(file_path):\n",
    "        # 파일이 존재하면, 데이터를 읽어옵니다.\n",
    "        collected_keywords_data = pd.read_csv(file_path)\n",
    "    else:\n",
    "        # 파일이 없으면, collect_keywords 함수를 호출해서 데이터를 수집합니다.\n",
    "        collected_keywords_data = await collect_keywords(srch_keyword, day)\n",
    "        # 결과를 CSV로 저장\n",
    "        collected_keywords_data.to_csv(file_path, index=False)\n",
    "    \n",
    "    return collected_keywords_data\n",
    "collected_keywords_data=asyncio.run(main(srch_keyword, day))\n",
    "\n",
    "collected_keywords_dat_copy=asyncio.run(main(srch_keyword, day))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 중복검색어컬럼 생성\n",
    "temp_df = utils.generate_unique_search_terms(collected_keywords_dat_copy)\n",
    "\n",
    "## 중복제거하고 50개씩 뽑는 로직 \n",
    "##  check_list: 2250개의 데이터(선별함수에 사용될 검색어별 50개의 연관키워드)를 담고있는 리스트 ,\n",
    "##  collected_keywords_data: 사용할 df\n",
    "collected_keywords_data,check_list = utils.get_top_50_unique_items(collected_keywords_data,temp_df)\n",
    "collected_keywords_data= utils.add_client_info(collected_keywords_data)\n",
    "new_columns = ['일별급상승', '주별급상승', '월별급상승', '주별지속상승', '월별지속상승', '월별규칙성']\n",
    "\n",
    "for column in new_columns:\n",
    "    collected_keywords_data[column] = 0\n",
    "def groupped_df(name,collected_keywords_data):\n",
    "    grouped = collected_keywords_data.groupby(name)\n",
    "    df_list = [group for _, group in grouped]\n",
    "    return df_list\n",
    "df_list=groupped_df('id',collected_keywords_data)\n",
    "n=len(df_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 데이터를 로드하거나 크롤링하여 반환하는 비동기 함수\n",
    "async def load_or_crawl_data(df_list, clients):\n",
    "    today_date_str = datetime.now().strftime(\"%y%m%d\")\n",
    "    directory = f\"./data/trend_data/{today_date_str}\"\n",
    "    save_path = f\"{directory}/data_{today_date_str}.pkl\"\n",
    "    \n",
    "    # 파일이 존재하면 데이터 로드\n",
    "    if os.path.exists(save_path):\n",
    "        with open(save_path, 'rb') as f:\n",
    "            results = pickle.load(f)\n",
    "    else:\n",
    "        # 파일이 없으면 비동기 크롤링 시작\n",
    "        results = await run_all(df_list, clients)\n",
    "        # 결과 데이터 저장\n",
    "        if not os.path.exists(directory):\n",
    "            os.makedirs(directory)\n",
    "        with open(save_path, 'wb') as f:\n",
    "            pickle.dump(results, f)\n",
    "    \n",
    "    return results\n",
    "\n",
    "# 비동기 크롤링 함수\n",
    "async def trend_main(df, clients):\n",
    "    params = {\n",
    "        \"search_keywords\": list(df['연관키워드']),\n",
    "        \"id\": df['id'].iloc[0],\n",
    "        \"pw\": df['pw'].iloc[0],\n",
    "        \"api_url\": \"https://openapi.naver.com/v1/datalab/search\",\n",
    "        \"name\": '연관검색어'\n",
    "    }\n",
    "    api_url = \"https://openapi.naver.com/v1/datalab/search\"\n",
    "    \n",
    "    # trend_maincode 함수 실행\n",
    "    results = await trend.trend_maincode(params, clients, api_url)\n",
    "    return results\n",
    "\n",
    "async def run_all(df_list, clients):\n",
    "    tasks = [trend_main(df, clients) for df in df_list]\n",
    "    results = await asyncio.gather(*tasks)\n",
    "    return results\n",
    "\n",
    "clients = utils.get_secret(\"clients\")  # clients 정보를 로드\n",
    "\n",
    "# 이벤트 루프 실행 및 데이터 로드 또는 크롤링\n",
    "trend_main_data = asyncio.run(load_or_crawl_data(df_list, clients))\n",
    "results = trend_main_data.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "병렬로 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 전역 변수로 리스트 초기화\n",
    "month_rule_list_a = []\n",
    "rising_list_a = [[], []]  # 주별 상승, 월별 상승\n",
    "select_list_a = [[], [], []]  # 일별 선택, 주별 선택, 월별 선택\n",
    "execute_analysis(results,month_rule_list_a,rising_list_a,select_list_a)\n",
    "\n",
    "\n",
    "# month_rule_list=[]\n",
    "select_list=[[],[],[]]\n",
    "\n",
    "rising_list=[[],[]]\n",
    "rising_month_list=[]\n",
    "\n",
    "\n",
    "# 각 리스트를 처리\n",
    "select_list[0] = process_results(select_list_a[0])\n",
    "select_list[1] = process_results(select_list_a[1])\n",
    "select_list[2] = process_results(select_list_a[2])\n",
    "\n",
    "rising_list[0] = process_results(rising_list_a[0])\n",
    "rising_list[1] = process_results(rising_list_a[1])\n",
    "\n",
    " # month_rule_list_a를 처리하면서 추가 데이터 처리를 포함\n",
    "month_rule_list = []  # 초기화가 필요할 수 있습니다.\n",
    "for result in month_rule_list_a:\n",
    "    if not all(value is None for value in result) and result[0] is not None:\n",
    "        column_names = result[0].columns\n",
    "        data_values_list = result[0][column_names].values.flatten()  # 데이터를 1D 배열로 변환\n",
    "        additional_data = {\n",
    "            'Indicator': data_values_list.tolist(),  # numpy 배열을 리스트로 변환\n",
    "            'RisingMonth': result[3],\n",
    "            '유형': '월별규칙성'  # 모든 결과에 대해 '유형'을 '월별규칙성'으로 설정\n",
    "        }\n",
    "        month_rule_list += process_results_month([result], additional_data=additional_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\s_chohy121212\\AppData\\Local\\Temp\\ipykernel_29592\\1937458494.py:23: FutureWarning: A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\n",
      "The behavior will change in pandas 3.0. This inplace method will never work because the intermediate object on which we are setting values always behaves as a copy.\n",
      "\n",
      "For example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' or df[col] = df[col].method(value) instead, to perform the operation inplace on the original object.\n",
      "\n",
      "\n",
      "  graph_result['유형'].replace({'주간지속상승': '주별지속상승'}, inplace=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 리스트와 유형을 매핑\n",
    "lists_and_types = [\n",
    "    (select_list[0], '일별급상승'),\n",
    "    (select_list[1], '주별급상승'),\n",
    "    (select_list[2], '월별급상승'),\n",
    "    (rising_list[0], '주별지속상승'),\n",
    "    (rising_list[1], '월별지속상승'),\n",
    "    (month_rule_list, '월별규칙성')\n",
    "]\n",
    "\n",
    "\n",
    "# 모든 리스트를 처리하고 하나의 데이터프레임으로 병합\n",
    "processed_dfs = [utils.process_and_concat(df_list, label) for df_list, label in lists_and_types]\n",
    "\n",
    "\n",
    "# 비어 있지 않은 DataFrame들만 병합\n",
    "graph_result = pd.concat([df for df in processed_dfs if not df.empty]).reset_index(drop=True)\n",
    "\n",
    "graph_result.reset_index(drop=True, inplace=True)\n",
    "# 불필요한 컬럼 삭제 및 '주간지속상승'을 '주별지속상승'으로 수정\n",
    "\n",
    "\n",
    "graph_result['유형'].replace({'주간지속상승': '주별지속상승'}, inplace=True)\n",
    "graph_result['RisingMonth'] = graph_result['RisingMonth'].replace({None: 0})\n",
    "graph_result['RisingMonth'] = graph_result['RisingMonth'].fillna(' ')\n",
    "# # 정렬\n",
    "graph_result.sort_values(by=['연관검색어', '유형', '검색일자'], ascending=[True, True, True], inplace=True)\n",
    "\n",
    "# # 최종 결과 출력 ( 그래프 함수  )\n",
    "graph_result.reset_index(drop=True, inplace=True)\n",
    "print(1)\n",
    "############################################################################################################\n",
    "\n",
    "\n",
    "flags_and_lists = [\n",
    "    (\"일별 급상승\", select_list[0]),\n",
    "    (\"주별 급상승\", select_list[1]),\n",
    "    (\"주별 지속상승\", rising_list[0]),\n",
    "    (\"월별 급상승\", select_list[2]),\n",
    "    (\"월별 지속상승\", rising_list[1]),\n",
    "    (\"월별 규칙성\", month_rule_list),\n",
    "]\n",
    "for flag_name, data_list in flags_and_lists:\n",
    "    # data_list가 리스트인지 확인\n",
    "    if not isinstance(data_list, list):\n",
    "        print(f\"{flag_name}: data_list가 리스트가 아닙니다.\")\n",
    "        continue\n",
    "    \n",
    "    # data_list 내의 각 요소가 DataFrame인지, '연관검색어' 컬럼이 있는지 확인\n",
    "    for idx, df in enumerate(data_list):\n",
    "        if not isinstance(df, pd.DataFrame):\n",
    "            print(f\"{flag_name}: 인덱스 {idx}에 DataFrame이 아닌 요소가 있습니다.\")\n",
    "        elif \"연관검색어\" not in df.columns:\n",
    "            print(f\"{flag_name}: 인덱스 {idx}의 DataFrame에 '연관검색어' 컬럼이 없습니다.\")\n",
    "\n",
    "# utils.update_keywords_flag 함수를 호출하기 전에 각 data_list의 유효성 검사\n",
    "for flag_name, data_list in flags_and_lists:\n",
    "    # 데이터 프레임으로 구성된 리스트만 유지\n",
    "    valid_data_list = [df for df in data_list if isinstance(df, pd.DataFrame) and \"연관검색어\" in df.columns]\n",
    "    \n",
    "    # 유효한 데이터 리스트만을 사용하여 키워드 플래그 업데이트\n",
    "    utils.update_keywords_flag(collected_keywords_data, valid_data_list, flag_name)\n",
    " # process_data : 지정된 조건에 따라 데이터를 필터링하고, 추가 처리를 통해 최종 데이터프레임을 반환하는 함수.\n",
    "def safe_process_data(process_function, data, category1, category2, selection):\n",
    "    \"\"\"\n",
    "    process_function: 데이터 처리 함수 (예: utils.process_data)\n",
    "    data: 처리할 데이터프레임\n",
    "    category1, category2: 데이터 처리 함수에 전달될 카테고리 인자\n",
    "    selection: 데이터 처리 함수에 전달될 선택 리스트 또는 기타 인자\n",
    "    \n",
    "    반환값: 처리된 데이터프레임 또는 빈 데이터프레임\n",
    "    \"\"\"\n",
    "    if data is not None and not data.empty:\n",
    "        try:\n",
    "            return process_function(data, category1, category2, selection)\n",
    "        except Exception as e:\n",
    "            print(f\"Error processing data: {e}\")\n",
    "            # 처리 중 오류가 발생한 경우 빈 데이터프레임 반환\n",
    "            return pd.DataFrame()\n",
    "    else:\n",
    "        print(\"No data available.\")\n",
    "        return pd.DataFrame()\n",
    "\n",
    "info_result_daily_select = safe_process_data(utils.process_data, collected_keywords_data, '일별 급상승', '일별 급상승', select_list[0])\n",
    "\n",
    "info_result_weekly_select = utils.process_data(collected_keywords_data, '주별 급상승', '주별 급상승', select_list[1])\n",
    "info_result_monthly_select = utils.process_data(collected_keywords_data, '월별 급상승', '월별 급상승', select_list[2]) \n",
    "\n",
    "info_result_weekly_continuous = utils.process_data(collected_keywords_data, '주별 지속상승', '주별 지속상승', rising_list[0])\n",
    "\n",
    "info_result_monthly_continuous = utils.process_data(collected_keywords_data, '월별 지속상승', '월별 지속상승', rising_list[1])\n",
    "\n",
    "info_result_monthly_pattern = utils.process_data(collected_keywords_data, '월별 규칙성', '월별 규칙성', month_rule_list)\n",
    "\n",
    "info_result_final = pd.concat([info_result_daily_select,info_result_weekly_select, info_result_monthly_select,\\\n",
    "                               info_result_weekly_continuous, info_result_monthly_continuous,\\\n",
    "                                  info_result_monthly_pattern]).reset_index(drop=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 구글/ 네이버 한꺼번에"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 뉴스링크,제목 수집 (네이버)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def collect_google_keywords(target_keywords):\n",
    "    today_date = datetime.now().strftime(\"%y%m%d\")\n",
    "    directory_path = f\"./data/trend_data/{today_date}\"\n",
    "    file_path = os.path.join(directory_path, f\"google_data_{today_date}.pkl\")\n",
    "    \n",
    "    if not os.path.exists(directory_path):\n",
    "        os.makedirs(directory_path)\n",
    "    \n",
    "    if os.path.exists(file_path):\n",
    "        with open(file_path, 'rb') as file:\n",
    "            rising_keywords_results = pickle.load(file)\n",
    "    else:\n",
    "        rising_keywords_results = await collect_rising_keywords(target_keywords)\n",
    "        with open(file_path, 'wb') as file:\n",
    "            pickle.dump(rising_keywords_results, file)\n",
    "    \n",
    "    return rising_keywords_results\n",
    "\n",
    "async def collect_news_keywords(target_keywords):\n",
    "    today_date = datetime.now().strftime(\"%y%m%d\")\n",
    "    directory_path = f\"./data/trend_data/{today_date}\"\n",
    "    file_path = os.path.join(directory_path, f\"news_data_{today_date}.pkl\")\n",
    "    \n",
    "    if not os.path.exists(directory_path):\n",
    "        os.makedirs(directory_path)\n",
    "    \n",
    "    if os.path.exists(file_path):\n",
    "        with open(file_path, 'rb') as file:\n",
    "            news_data = pickle.load(file)\n",
    "    else:\n",
    "        news_data = await main_news(target_keywords)\n",
    "        with open(file_path, 'wb') as file:\n",
    "            pickle.dump(news_data, file)\n",
    "    \n",
    "    return news_data\n",
    "\n",
    "# 메인 비동기 실행 함수\n",
    "async def main(target_keywords):\n",
    "    google_keywords_results, news_keywords_results = await asyncio.gather(\n",
    "        collect_google_keywords(target_keywords),\n",
    "        collect_news_keywords(target_keywords)\n",
    "    )\n",
    "    \n",
    "    return google_keywords_results, news_keywords_results\n",
    "\n",
    "\n",
    "\n",
    "target_keywords = list(set(info_result_final['연관키워드']))\n",
    "rising_keywords_results,news_data=asyncio.run(main(target_keywords))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./data/target_keywords/240625\\target_keywords.txt에 키워드 저장됨\n",
      "./data/target_keywords/240625/keyword_activity_rates.csv에 작업 결과가 저장될 것입니다.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "################################\n",
    "#활동성 분석\n",
    "################################\n",
    "import subprocess\n",
    "today_date = datetime.now().strftime(\"%y%m%d\")\n",
    "directory_path = f\"./data/target_keywords/{today_date}\"\n",
    "file_path = os.path.join(directory_path, \"target_keywords.txt\")\n",
    "\n",
    "if not os.path.exists(directory_path):\n",
    "    # 디렉토리가 존재하지 않는 경우, 디렉토리 생성\n",
    "    os.makedirs(directory_path)\n",
    "\n",
    "# 파일이 존재하는지 확인\n",
    "if not os.path.exists(file_path):\n",
    "    # 키워드를 파일에 작성\n",
    "    with open(file_path, 'w') as file:\n",
    "        for keyword in target_keywords:\n",
    "            file.write(\"%s\\n\" % keyword)\n",
    "    result = f\"{file_path}에 키워드 저장됨\"\n",
    "else:\n",
    "    result = f\"{file_path} 파일이 이미 존재합니다. 작업을 건너뜁니다.\"\n",
    "print(result)\n",
    "\n",
    "# 파일이 존재하지 않는 경우, blog_data_collector.py 스크립트를 실행\n",
    "file_path = f\"./data/target_keywords/{today_date}/keyword_activity_rates.csv\"\n",
    "if not os.path.exists(file_path):\n",
    "    command = f\"python  models/naver/blog.py\"\n",
    "    process = subprocess.run(command, shell=True, check=True)\n",
    "    result = f\"{file_path}에 작업 결과가 저장될 것입니다.\"\n",
    "else:\n",
    "    result = f\"{file_path} 파일이 이미 존재합니다. 작업을 건너뜁니다.\"\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# merge "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_keyword_activity_rates=formatting.merge_data(news_data,directory_path)\n",
    "final_merged_df_copy=formatting.merge_result(collected_keywords_dat_copy,info_result_final,merged_keyword_activity_rates,rising_keywords_results)\n",
    "info_data,combined_df=formatting.reults_formatted(info_result_final,final_merged_df_copy,graph_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 결과 저장 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_csv = utils.make_csv(info_data)\n",
    "\n",
    "# 현재 날짜를 'yyMMdd' 형식으로 포맷팅\n",
    "today = datetime.now(timezone('Asia/Seoul'))\n",
    "formatted_today = today.strftime('%y%m%d')\n",
    "\n",
    "# 저장할 경로\n",
    "save_path = f'./data/result_out/{formatted_today}'\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# 해당 경로가 존재하지 않으면 생성\n",
    "if not os.path.exists(save_path):\n",
    "    os.makedirs(save_path)\n",
    "\n",
    "# CSV 파일 저장\n",
    "result_csv.to_csv(f'{save_path}/info_{formatted_today}.csv', encoding='utf-8-sig', index=False, header=False)\n",
    "\n",
    "# 구분자 ,\n",
    "combined_df.to_csv(f'{save_path}/graph_{formatted_today}_in.csv', encoding='utf-8-sig', index=False, header=False)\n",
    "info_data.to_csv(f'{save_path}/info_{formatted_today}_in.csv', encoding='utf-8-sig', index=False, header=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "result_graph = utils.make_csv(combined_df)\n",
    "\n",
    "\n",
    "# 현재 날짜를 'yyMMdd' 형식으로 포맷팅\n",
    "today = datetime.now(timezone('Asia/Seoul'))\n",
    "formatted_today = today.strftime('%y%m%d')\n",
    "\n",
    "# 저장할 경로\n",
    "save_path = f'./data/result_out/{formatted_today}'\n",
    "\n",
    "# 해당 경로가 존재하지 않으면 생성\n",
    "if not os.path.exists(save_path):\n",
    "    os.makedirs(save_path)\n",
    "\n",
    "# CSV 파일 저장\n",
    "result_graph.to_csv(f'{save_path}/graph_{formatted_today}.csv', encoding='utf-8-sig', index=False, header=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}