collector_api

+from collections import OrderedDict
+from sqlalchemy import Integer, Text
+import numpy
+import pathlib
+import os
+import time
+from PyQt5.QtWidgets import *
+from pandas import DataFrame
+
+from open_api import *
+from daily_buy_list import *
+
+# open_api를 이용하여 데이터베이스에 정보를 저장하는 클래스
+class collector_api():
+    def __init__(self):
+        self.open_api = open_api()
+        self.engine_bot = self.open_api.engine_bot
+        self.variable_setting()
+
+    # 변수설정
+    def variable_setting(self):
+        self.open_api.py_gubun = "collector"        # 용도를 저장하는 변수. collector : 데이터 저장 / trader : 종목 거래
+        self.dc = daily_crawler(self.open_api.cf.real_db_name, self.open_api.cf.real_daily_craw_db_name,
+                                self.open_api.cf.real_daily_buy_list_db_name)
+        self.dbl = daily_buy_list()
+
+    # 콜렉팅을 실행하는 함수
+    def code_update_check(self):
+        logger.debug("code_update_check function")
+        query = "select jango_data_db_check, possessed_item, today_profit, final_chegyul_check, " \
+                "db_to_buy_list,today_buy_list, daily_crawler , min_crawler, daily_buy_list from setting_data limit 1"
+
+        rows = self.engine_bot.execute(query).fetchall()
+
+        # 잔고/보유종목 업데이트 확인
+        if rows[0][0] != self.open_api.today or rows[0][1] != self.open_api.today:
+            self.py_check_balance()
+            self.open_api.set_invest_unit()
+
+        # possessed_item(현재 보유종목) 테이블 업데이트
+        if rows[0][1] != self.open_api.today:
+            self.open_api.db_to_possesed_item()
+            self.open_api.setting_data_possesed_item()
+
+        # 당일 종목별 실현 손익 내역 테이블 업데이트
+        if rows[0][2] != self.open_api.today:
+            self.db_to_today_profit_list()
+
+        # daily_craw 데이터베이스 업데이트
+        if rows[0][6] != self.open_api.today:
+            self.daily_crawler_check()
+
+        # daily_buy_list 데이터베이스 업데이트
+        if rows[0][8] != self.open_api.today:
+            self.daily_buy_list_check()
+
+        # 매수/매도 후 daily_buy_list 데이터베이스 업데이트
+        if rows[0][3] != self.open_api.today:
+            self.open_api.chegyul_check()           # 매수 후 all_stocks에 저장되지 않은 종목 처리
+            self.open_api.final_chegyul_check()     # # 매도 후 all_stocks에 sell_date가 업데이트 되지 않은 항목 처리
+
+        # 다음날 매수 종목 테이블(realtime_daily_buy_list) 업데이트
+        if rows[0][5] != self.open_api.today:
+            self.realtime_daily_buy_list_check()
+
+        # min_craw db (분별 데이터) 업데이트
+        if rows[0][7] != self.open_api.today:
+            self.min_crawler_check()
+
+        logger.debug("collecting 작업을 모두 정상적으로 마쳤습니다.")
+
+        # cmd 콘솔창 종료
+        os.system("@taskkill /f /im cmd.exe")
+
+    # 매수 종목 설정 함수
+    def realtime_daily_buy_list_check(self):
+        # daily_buy_list 데이터베이스에 오늘 날짜의 테이블이 존재하는 경우, realtime_daily_buy_list 테이블 생성
+        if self.open_api.sf.is_date_exist(self.open_api.today):
+            self.open_api.sf.get_date_for_simul()
+            self.open_api.sf.db_to_realtime_daily_buy_list(self.open_api.today, self.open_api.today, len(self.open_api.sf.date_rows))
+
+            # all_stocks 테이블을 오늘 일자 데이터로 업데이트 한다.
+            self.open_api.sf.update_all_db_by_date(self.open_api.today)
+            self.open_api.rate_check()
+            # realtime_daily_buy_list(매수 리스트) 테이블 세팅을 완료 후, setting_data의 today_buy_list에 오늘 날짜를 저장
+            query = "UPDATE setting_data SET today_buy_list='%s' limit 1"
+            self.engine_bot.execute(query % (self.open_api.today))
+
+        else:
+            logger.debug(
+                """daily_buy_list DB에 {} 테이블이 없습니다. realtime_daily_buy_list 테이블을 생성 할 수 없습니다.
+                아래 내역을 확인하세요.
+                1. 장이 열리지 않은 날 혹은 15시 30분 ~ 23시 59분 사이에 콜렉터를 돌리지 않은 경우 
+                2. 콜렉터를 오늘 날짜 까지 돌리지 않아 daily_buy_list의 오늘 날짜 테이블이 없는 경우
+                """.format(self.open_api.today))
+
+    # daily_buy_list 데이터베이스에 테이블이 존재하는지 확인하는 함수
+    def is_table_exist_daily_buy_list(self, date):
+        query = "select 1 from information_schema.tables where table_schema ='daily_buy_list' and table_name = '%s'"
+        rows = self.open_api.engine_daily_buy_list.execute(query % (date)).fetchall()
+
+        if len(rows) == 1:
+            return True
+        elif len(rows) == 0:
+            return False
+
+    # min_craw 데이터베이스에 테이블이 존재하는지 확인하는 함수
+    def is_table_exist(self, db_name, table_name):
+        query = "select 1 from information_schema.tables where table_schema ='{}' and table_name = '{}'"
+        rows = self.open_api.engine_craw.execute(query.format(db_name, table_name)).fetchall()
+        if len(rows) == 1:
+            return True
+        elif len(rows) == 0:
+            return False
+
+    # daily_buy_list 테이블 생성 및 데이터 저장하는 함수
+    def daily_buy_list_check(self):
+        self.dbl.daily_buy_list()
+
+        query = "UPDATE setting_data SET daily_buy_list='%s' limit 1"
+        self.engine_bot.execute(query % (self.open_api.today))
+
+    # min_craw 데이터베이스 생성 함수
+    def db_to_min_craw(self):
+        query = "select code,code_name,check_min_crawler from stock_item_all"
+        target_code = self.open_api.engine_daily_buy_list.execute(query).fetchall()
+        num = len(target_code)
+
+        query = "UPDATE stock_item_all SET check_min_crawler='%s' WHERE code='%s'"
+
+        for i in range(num):
+            # check_item이 0이 아니면 다음 항목 처리
+            if int(target_code[i][2]) != 0:
+                continue
+
+            code = target_code[i][0]
+            code_name = target_code[i][1]
+
+            logger.debug("++++++++++++++" + str(code_name) + "++++++++++++++++++++" + str(i + 1) + '/' + str(num))
+
+            check_item_gubun = self.set_min_crawler_table(code, code_name)
+
+            self.open_api.engine_daily_buy_list.execute(query % (check_item_gubun, code))
+
+    # 당일 daily_craw 데이터베이스의 업데이트 내역을 확인하고, 업데이트를 실행하는 함수
+    def db_to_daily_craw(self):
+        query = "select code,code_name,check_daily_crawler from stock_item_all"
+
+        target_code = self.open_api.engine_daily_buy_list.execute(query).fetchall()
+        num = len(target_code)
+        query = "UPDATE stock_item_all SET check_daily_crawler='%s' WHERE code='%s'"
+
+        # check_daily_crawler : daily_craw 데이터베이스를 업데이트 했는지 확인하는 변수
+        # 1: 당일 업데이트 완료 / 3 : 과거에 업데이트 완료 / 0 : 업데이트 전 / 4 : daily_buy_list에 내용 변동을 업데이트 필요
+        # check_daily_crawler이 1,3이 아닌 경우 업데이트 실행
+        for i in range(num):
+            if int(target_code[i][2]) in (1, 3):
+                continue
+
+            code = target_code[i][0]
+            code_name = target_code[i][1]
+
+            logger.debug("++++++++++++++" + str(code_name) + "++++++++++++++++++++" + str(i + 1) + '/' + str(num))
+
+            check_item_gubun = self.set_daily_crawler_table(code, code_name)
+
+            self.open_api.engine_daily_buy_list.execute(query % (check_item_gubun, code))
+
+    # min_crawler 데이터베이스에 콜렉팅을 완료했는지 확인하는 함수
+    def min_crawler_check(self):
+        self.db_to_min_craw()
+
+        query = "UPDATE setting_data SET min_crawler='%s' limit 1"
+        self.engine_bot.execute(query % (self.open_api.today))
+
+    # daily_crawler 데이터베이스에 콜렉팅을 완료했는지 확인하는 함수
+    def daily_crawler_check(self):
+        self.db_to_daily_craw()
+        logger.debug("daily_crawler success !!!")
+
+        sql = "UPDATE setting_data SET daily_crawler='%s' limit 1"
+        self.engine_JB.execute(sql % (self.open_api.today))
+
+    # 틱(1분 별) 데이터를 가져오는 함수
+    def set_min_crawler_table(self, code, code_name):
+        df = self.open_api.get_total_data_min(code, code_name, self.open_api.today)
+
+        df_temp = DataFrame(df,
+                            columns=['date', 'check_item', 'code', 'code_name', 'd1_diff_rate',
+                                     'close', 'open', 'high','low','volume', 'sum_volume',
+                                     'clo5', 'clo10', 'clo20', 'clo60','clo120',
+                                     "clo5_diff_rate", "clo10_diff_rate","clo20_diff_rate", "clo60_diff_rate",
+                                     "clo120_diff_rate",
+                                     'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60', 'yes_clo120',
+                                     'vol5', 'vol10', 'vol20', 'vol60', 'vol120'
+                                     ])
+
+        df_temp = df_temp.sort_values(by=['date'], ascending=True)
+
+        df_temp['code'] = code
+        df_temp['code_name'] = code_name
+        d1_diff_rate = round((df_temp['close'] - df_temp['close'].shift(1)) / df_temp['close'].shift(1) * 100, 2)
+        df_temp['d1_diff_rate'] = d1_diff_rate.replace(numpy.inf, numpy.nan)
+
+        clo5 = df_temp['close'].rolling(window=5).mean()
+        clo10 = df_temp['close'].rolling(window=10).mean()
+        clo20 = df_temp['close'].rolling(window=20).mean()
+        clo60 = df_temp['close'].rolling(window=60).mean()
+        clo120 = df_temp['close'].rolling(window=120).mean()
+        df_temp['clo5'] = round(clo5, 2)
+        df_temp['clo10'] = round(clo10, 2)
+        df_temp['clo20'] = round(clo20, 2)
+        df_temp['clo60'] = round(clo60, 2)
+        df_temp['clo120'] = round(clo120, 2)
+
+        df_temp['clo5_diff_rate'] = round((df_temp['close'] - clo5) / clo5 * 100, 2)
+        df_temp['clo10_diff_rate'] = round((df_temp['close'] - clo10) / clo10 * 100, 2)
+        df_temp['clo20_diff_rate'] = round((df_temp['close'] - clo20) / clo20 * 100, 2)
+        df_temp['clo60_diff_rate'] = round((df_temp['close'] - clo60) / clo60 * 100, 2)
+        df_temp['clo120_diff_rate'] = round((df_temp['close'] - clo120) / clo120 * 100, 2)
+
+        df_temp['yes_clo5'] = df_temp['clo5'].shift(1)
+        df_temp['yes_clo10'] = df_temp['clo10'].shift(1)
+        df_temp['yes_clo20'] = df_temp['clo20'].shift(1)
+        df_temp['yes_clo60'] = df_temp['clo60'].shift(1)
+        df_temp['yes_clo120'] = df_temp['clo120'].shift(1)
+
+        df_temp['vol5'] = df_temp['volume'].rolling(window=5).mean()
+        df_temp['vol10'] = df_temp['volume'].rolling(window=10).mean()
+        df_temp['vol20'] = df_temp['volume'].rolling(window=20).mean()
+        df_temp['vol60'] = df_temp['volume'].rolling(window=60).mean()
+        df_temp['vol120'] = df_temp['volume'].rolling(window=120).mean()
+
+        # 분별 테이블이 존재한다면, 가장 최근의 분 데이터 이후의 값을 저장
+        if self.open_api.craw_table_exist:
+            df_temp = df_temp[df_temp.date > self.open_api.craw_db_last_min]
+
+        # 추가할 내역이 없다면, check_item_gubun=3
+        if len(df_temp) == 0:
+            time.sleep(0.03)
+            check_item_gubun = 3
+            return check_item_gubun
+
+        df_temp[['close', 'open', 'high', 'low', 'volume', 'sum_volume', 'clo5', 'clo10', 'clo20', 'clo60','clo120',
+                 'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60','yes_clo120',
+                 'vol5', 'vol10', 'vol20', 'vol60', 'vol120']] = \
+            df_temp[
+                ['close', 'open', 'high', 'low', 'volume', 'sum_volume', 'clo5', 'clo10', 'clo20', 'clo60', 'clo120',
+                 'yes_clo5', 'yes_clo10', 'yes_clo20','yes_clo60', 'yes_clo120',
+                 'vol5', 'vol10', 'vol20', 'vol60', 'vol120']].fillna(0).astype(int)
+
+        temp_date = self.open_api.craw_db_last_min
+        sum_volume = self.open_api.craw_db_last_min_sum_volume
+
+        for i in range(len(df_temp),-1,-1):
+            try:
+                temp_index = i
+
+                # 데이터가 하루 이상 차이날 경우, sum_volume 초기화
+                if ((int(df_temp.loc[temp_index, 'date']) - int(temp_date)) > 9000):
+                    sum_volume = 0
+
+                temp_date = df_temp.loc[temp_index, 'date']
+                # 분별로 sum_volume값 누적 저장
+                sum_volume += df_temp.loc[temp_index, 'volume']
+                df_temp.loc[temp_index, 'sum_volume'] = sum_volume
+
+            except Exception as e:
+                logger.critical(e)
+
+        df_temp.to_sql(name=code_name, con=self.open_api.engine_craw, if_exists='append')
+        # 콜렉팅하다가 max_api_call 횟수까지 가게 된 경우
+        # 이후 콜렉팅 하지 못한 정보를 가져오기 위해 check_item_gubun=0
+        if self.open_api.rq_count == cf.max_api_call - 1:
+            check_item_gubun = 0
+        # 정상완료한 경우 check_item_gubun=1
+        else:
+            check_item_gubun = 1
+        return check_item_gubun
+
+    # daily_crawler(종목별 일일 데이터) 테이블 생성 및 내역을 추가하는 함수
+    # daily_crawler 테이블 업데이트 후, daily_buy_list(일별 종목 데이터) 테이블 생성 및 내역 추가
+    def set_daily_crawler_table(self, code, code_name):
+        df = self.open_api.get_total_data(code, code_name, self.open_api.today)
+        oldest_row = df.iloc[-1]        # 가장 최신 데이터
+        check_row = None
+
+        check_dc_query = "UPDATE daily_buy_list.stock_item_all SET check_daily_crawler = '4' WHERE code = '{}'"
+
+        # 특정 종목명(code_name)의 테이블이 존재하는 경우
+        if self.engine_bot.dialect.has_table(self.open_api.engine_daily_craw, code_name):
+            query=f"select * from '{code_name}' where date='{oldest_row['date']}' limit 1"
+            check_row = self.open_api.engine_daily_craw.execute(query).fetchall()
+        # 종목명 테이블이 존재하지 않는 경우, 종목 리스트(stock_item_all) 테이블에 check_daily_crawler=4 업데이트
+        else:
+            self.engine_bot.execute(check_dc_query.format(code))
+
+        # 종목 테이블에 저장된 가장 최신의 데이터가 실제 가장 최신 데이터와 같지 않다면 다시 테이블 삭제 후 다시 생성
+        if check_row and check_row[0]['close'] != oldest_row['close']:
+            # 테이블 삭제
+            logger.info('daily_craw와 min_craw 삭제 중..')
+            commands = [
+                f"DROP TABLE IF EXISTS daily_craw.'{code_name}'",
+                f"DROP TABLE IF EXISTS min_craw.'{code_name}"
+            ]
+
+            for com in commands:
+                self.open_api.engine_daily_buy_list.execute(com)
+            logger.info('삭제 완료')
+
+            # 테이블 생성
+            df = self.open_api.get_total_data(code, code_name, self.open_api.today)
+            self.engine_bot.execute(check_dc_query.format(code))
+
+        query=f"select check_daily_crawler from daily_buy_list.stock_item_all where code='{code}'"
+        check_daily_crawler = self.engine_bot.execute(query).fetchall()[0].check_daily_crawler
+
+        df_temp = DataFrame(df,
+                            columns=['date', 'check_item', 'code', 'code_name', 'd1_diff_rate',
+                                     'close', 'open', 'high','low','volume',
+                                     'clo5', 'clo10', 'clo20', 'clo60', 'clo120',
+                                     "clo5_diff_rate", "clo10_diff_rate","clo20_diff_rate", "clo60_diff_rate",
+                                     "clo120_diff_rate",
+                                     'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60', 'yes_clo120',
+                                     'vol5', 'vol10', 'vol20', 'vol60', 'vol120', 'vol80'
+                                     ])
+
+        df_temp = df_temp.sort_values(by=['date'], ascending=True)
+
+        df_temp['code'] = code
+        df_temp['code_name'] = code_name
+        df_temp['d1_diff_rate'] = round(
+            (df_temp['close'] - df_temp['close'].shift(1)) / df_temp['close'].shift(1) * 100, 2)
+
+        clo5 = df_temp['close'].rolling(window=5).mean()
+        clo10 = df_temp['close'].rolling(window=10).mean()
+        clo20 = df_temp['close'].rolling(window=20).mean()
+        clo60 = df_temp['close'].rolling(window=60).mean()
+        clo120 = df_temp['close'].rolling(window=120).mean()
+        df_temp['clo5'] = clo5
+        df_temp['clo10'] = clo10
+        df_temp['clo20'] = clo20
+        df_temp['clo60'] = clo60
+        df_temp['clo120'] = clo120
+
+        df_temp['clo5_diff_rate'] = round((df_temp['close'] - clo5) / clo5 * 100, 2)
+        df_temp['clo10_diff_rate'] = round((df_temp['close'] - clo10) / clo10 * 100, 2)
+        df_temp['clo20_diff_rate'] = round((df_temp['close'] - clo20) / clo20 * 100, 2)
+        df_temp['clo60_diff_rate'] = round((df_temp['close'] - clo60) / clo60 * 100, 2)
+        df_temp['clo120_diff_rate'] = round((df_temp['close'] - clo120) / clo120 * 100, 2)
+
+        df_temp['yes_clo5'] = df_temp['clo5'].shift(1)
+        df_temp['yes_clo10'] = df_temp['clo10'].shift(1)
+        df_temp['yes_clo20'] = df_temp['clo20'].shift(1)
+        df_temp['yes_clo60'] = df_temp['clo60'].shift(1)
+        df_temp['yes_clo120'] = df_temp['clo120'].shift(1)
+
+        df_temp['vol5'] = df_temp['volume'].rolling(window=5).mean()
+        df_temp['vol10'] = df_temp['volume'].rolling(window=10).mean()
+        df_temp['vol20'] = df_temp['volume'].rolling(window=20).mean()
+        df_temp['vol60'] = df_temp['volume'].rolling(window=60).mean()
+        df_temp['vol120'] = df_temp['volume'].rolling(window=120).mean()
+
+        # daily_craw테이블이 존재할 경우, 저장되어있는 날짜 이후의 값을 저장
+        if self.engine_bot.dialect.has_table(self.open_api.engine_daily_craw, code_name):
+            df_temp = df_temp[df_temp.date > self.open_api.get_daily_craw_db_last_date(code_name)]
+
+        # 데이터가 없거나 이미 데이터 콜렉팅을 완료한 경우, check_item_gubun=3으로 설정
+        if len(df_temp) == 0 and check_daily_crawler != '4':
+            time.sleep(0.03)
+            check_item_gubun = 3
+            return check_item_gubun
+
+        df_temp[['close', 'open', 'high', 'low', 'volume', 'clo5', 'clo10', 'clo20', 'clo60','clo120',
+                 'yes_clo5', 'yes_clo10', 'yes_clo20','yes_clo60', 'yes_clo80','yes_clo120',
+                 'vol5', 'vol10', 'vol20', 'vol40', 'vol60', 'vol80', 'vol100', 'vol120']] = \
+            df_temp[
+                ['close', 'open', 'high', 'low', 'volume', 'clo5', 'clo10', 'clo20','clo60','clo120',
+                 'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60','yes_clo120',
+                 'vol5', 'vol10', 'vol20', 'vol40', 'vol60', 'vol80', 'vol100', 'vol120']].fillna(0).astype(int)
+
+        df_temp.to_sql(name=code_name, con=self.open_api.engine_daily_craw, if_exists='append')
+
+        # check_daily_crawler 가 4 인 경우는 액면분할, 증자 등으로 인해 daily_buy_list 업데이트를 해야하는 경우
+        # 업데이트 완료 후 check_item_gubun=1
+        if check_daily_crawler == '4':
+            logger.info(f'daily_craw.{code_name} 업데이트 완료 {code}')
+            logger.info('daily_buy_list 업데이트 중..')
+
+            query="SELECT table_name as tname FROM information_schema.tables " \
+                  "WHERE table_schema ='daily_buy_list' AND table_name REGEXP '[0-9]{8}"
+            dbl_dates = self.open_api.engine_daily_buy_list.execute(query).fetchall()
+
+            for row in dbl_dates:
+                logger.info(f'{code} {code_name} - daily_buy_list.`{row.tname}` 업데이트')
+                try:
+                    new_data = df_temp[df_temp['date'] == row.tname]
+                except IndexError:
+                    continue
+                query=f"delete from '{row.tname}' where code={code}"
+                self.open_api.engine_daily_buy_list.execute(query)
+                new_data.to_sql(name=row.tname, con=self.open_api.engine_daily_buy_list, if_exists='append')
+
+            logger.info('daily_buy_list 업데이트 완료')
+
+        check_item_gubun = 1
+        return check_item_gubun
+
+    # today_profit_list 테이블 생성 및 내역 추가 함수
+    def db_to_today_profit_list(self):
+        self.open_api.reset_opt10073_output()
+
+        self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+        self.open_api.set_input_value("시작일자", self.open_api.today)
+        self.open_api.set_input_value("종료일자", self.open_api.today)
+
+        self.open_api.comm_rq_data("opt10073_req", "opt10073", 0, "0328")
+
+        while self.open_api.remained_data:
+            self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+            self.open_api.comm_rq_data("opt10073_req", "opt10073", 2, "0328")
+
+        today_profit_item_temp = {'date': [], 'code': [], 'code_name': [], 'amount': [], 'today_profit': [],
+                                  'earning_rate': []}
+
+        today_profit_item = DataFrame(today_profit_item_temp,
+                                      columns=['date', 'code', 'code_name', 'amount', 'today_profit',
+                                               'earning_rate'])
+
+        item_count = len(self.open_api.opt10073_output['multi'])
+        for i in range(item_count):
+            row = self.open_api.opt10073_output['multi'][i]
+            today_profit_item.loc[i, 'date'] = row[0]                       # 날짜
+            today_profit_item.loc[i, 'code'] = row[1]                       # 종목코드
+            today_profit_item.loc[i, 'code_name'] = row[2]                  # 종목명
+            today_profit_item.loc[i, 'amount'] = int(row[3])                # 보유수량
+            today_profit_item.loc[i, 'today_profit'] = float(row[4])        # 당일실현손익
+            today_profit_item.loc[i, 'earning_rate'] = float(row[5])        # 수익률
+
+        if len(today_profit_item) > 0:
+            today_profit_item.to_sql('today_profit_list', self.engine_bot, if_exists='append')
+        query = "UPDATE setting_data SET today_profit='%s' limit 1"
+        self.engine_bot.execute(query % (self.open_api.today))
+
+    # jango 테이블 생성 및 내역 추가 함수
+    def db_to_jango(self):
+        self.total_invest = self.open_api.change_format(
+            str(int(self.open_api.d2_deposit_before_format) + int(self.open_api.total_purchase_price)))
+        jango_temp = {'id': [], 'date': [], 'total_asset': [], 'today_profit': [], 'total_profit': [],
+                      'total_invest': [], 'd2_deposit': [],
+                      'today_purchase': [], 'today_evaluation': [],
+                      'today_invest': [], 'today_rate': [],
+                      'estimate_asset': []}
+
+        jango_col_list = ['date',
+                          'today_earning_rate','total_evaluation',
+                          'total_profit', 'total_invest',
+                          'total_valuation','total_purchase','total_rate','today_profit','estimate_asset','d2_deposit',
+                          'volume_limit','sell_point','invest_limit_rate', 'invest_unit','limit_money',
+                          'total_profitcut','total_losscut','total_profitcut_count', 'total_losscut_count',
+                          'today_buy_count','total_sell_count','total_possess_count']
+
+        jango = DataFrame(jango_temp,
+                          columns=jango_col_list,
+                          index=jango_temp['id'])
+
+        jango.loc[0, 'date'] = self.open_api.today                                              # 날짜
+        jango.loc[0, 'total_evaluation'] = self.open_api.change_total_eval_price                # 총평가금액
+        jango.loc[0, 'total_profit'] = self.open_api.total_profit                               # 실현손익
+        jango.loc[0, 'total_invest'] = self.total_invest                                        # 총투자금액
+        jango.loc[0, 'total_valuation'] = self.open_api.change_total_eval_profit_loss_price     # 총평가손익금액
+        jango.loc[0, 'total_purchase'] = self.open_api.change_total_purchase_price              # 총매입금액
+
+        jango.loc[0, 'total_rate'] = float(self.open_api.change_total_earning_rate) / self.open_api.mod_gubun   # 총수익률
+        jango.loc[0, 'today_profit'] = self.open_api.today_profit                               # 당일매도손익
+        jango.loc[0, 'estimate_asset'] = self.open_api.change_estimated_deposit                 # 추정예탁자산
+        jango.loc[0, 'd2_deposit'] = self.open_api.d2_deposit                                   # 예수금
+        jango.loc[0, 'volume_limit'] = self.open_api.sf.volume_limit
+
+        jango.loc[0, 'sell_point'] = self.open_api.sf.sell_point                                # 매도기준수익률
+        jango.loc[0, 'invest_limit_rate'] = self.open_api.sf.invest_limit_rate                  # 매수기준수익률
+        jango.loc[0, 'invest_unit'] = self.open_api.invest_unit                                 # 투자기준금액
+        jango.loc[0, 'limit_money'] = self.open_api.sf.limit_money                              # 잔고에 남겨둘 최소금액
+
+        # 당일 익절 금액(today_profitcut), 당일 손절 금액(today_losscut)
+        if self.is_table_exist(self.open_api.db_name, "today_profit_list"):
+            query = "select sum(today_profit) from today_profit_list where today_profit >='%s' and date = '%s'"
+            rows = self.engine_bot.execute(query % (0, self.open_api.today)).fetchall()
+            if rows[0][0] is not None:
+                jango.loc[0, 'total_profitcut'] = int(rows[0][0])
+            else:
+                jango.loc[0,'total_profitcut']=0
+
+            query = "select sum(today_profit) from today_profit_list where today_profit < '%s' and date = '%s'"
+            rows = self.engine_bot.execute(query % (0, self.open_api.today)).fetchall()
+            if rows[0][0] is not None:
+                jango.loc[0, 'total_losscut'] = int(rows[0][0])
+            else:
+                jango.loc[0, 'total_losscut'] = 0
+
+        # 총 익절 종목 수(total_profitcut_count)
+        query = "select count(*) " \
+                "from (select code from all_stocks where sell_rate >='%s' and sell_date like '%s' group by code)"
+        rows = self.engine_bot.execute(query % (0, self.open_api.today + "%%")).fetchall()
+        jango.loc[0, 'total_profitcut_count'] = int(rows[0][0])
+
+        # 총 손절 종목 수(total_losscut_count)
+        query = "select count(*) " \
+                "from (select code from all_stocks where sell_rate < '%s' and sell_date like '%s' group by code)"
+        rows = self.engine_bot.execute(query % (0, self.open_api.today + "%%")).fetchall()
+        jango.loc[0, 'total_losscut_count'] = int(rows[0][0])
+
+        # jango_data 테이블 생성 및 데이터 추가
+        jango.to_sql('jango_data', self.engine_bot, if_exists='append')
+
+        query = "select date from jango_data"
+        rows = self.engine_bot.execute(query).fetchall()
+
+        for i in range(len(rows)):
+            # 당일 수익률 (today_earning_rate)
+            query = "update jango_data set " \
+                    "today_earning_rate =round(today_profit / total_invest  * '%s',2) WHERE date='%s'"
+            self.engine_bot.execute(query % (100, rows[i][0]))
+
+            # 당일 구매 종목 수 (today_buy_count)
+            query = "UPDATE jango_data SET " \
+                    "today_buy_count=" \
+                    "(select count(*) from (select code from all_stocks where buy_date like '%s' group by code)) " \
+                    "WHERE date='%s'"
+            self.engine_bot.execute(query % (rows[i][0] + "%%", rows[i][0]))
+
+            # 총 매수 종목 수 (total_sell_count)
+            query = "UPDATE jango_data SET " \
+                    "total_sell_count=" \
+                    "(select count(*) from " \
+                    "(select code from all_stocks a where sell_date!='0' group by code) temp)"\
+                    "WHERE date='%s'"
+            self.engine_bot.execute(query % (rows[i][0]))
+
+            # 총 보유 종목 수 (total_possess_count)
+            query = "UPDATE jango_data SET " \
+                    "today_buy_total_possess_count=" \
+                    "(select count(*) from (select code from all_stocks where sell_date = '0' group by code )) " \
+                    "WHERE date='%s'"
+            self.engine_bot.execute(query % (rows[i][0]))
+
+        query = "UPDATE setting_data SET jango_data_db_check='%s' limit 1"
+        self.engine_bot.execute(query % (self.open_api.today))
+
+    # 계좌정보 확인 함수
+    def py_check_balance(self):
+        logger.debug("py_check_balance!!!")
+
+        # 예수금상세현황
+        self.open_api.reset_opw00018_output()
+
+        self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+        self.open_api.set_input_value("비밀번호입력매체구분", 00)
+        self.open_api.set_input_value("조회구분", 1)
+        self.open_api.comm_rq_data("opw00001_req", "opw00001", 0, "2000")
+
+        # 계좌평가잔고내역
+        self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+        self.open_api.comm_rq_data("opw00018_req", "opw00018", 0, "2000")
+
+        while self.open_api.remained_data:
+            self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+            self.open_api.comm_rq_data("opw00018_req", "opw00018", 2, "2000")
+
+        # 일자별실현손익
+        self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+        self.open_api.set_input_value("시작일자", "20170101")
+        self.open_api.set_input_value("종료일자", self.open_api.today)
+
+        self.open_api.comm_rq_data("opt10074_req", "opt10074", 0, "0329")
+        while self.open_api.remained_data:
+            self.open_api.set_input_value("계좌번호", self.open_api.account_number)
+            self.open_api.set_input_value("시작일자", "20170101")
+            self.open_api.set_input_value("종료일자", "20180930")
+
+            # 	구분 = 0:전체, 1:입출금, 2:입출고, 3:매매, 4:매수, 5:매도, 6:입금, 7:출금, A:예탁담보대출입금, F:환전
+            self.open_api.set_input_value("구분", "0")
+            self.open_api.comm_rq_data("opt10074_req", "opt10074", 2, "0329")
+
+        self.db_to_jango()

@@ -41,7 +41,7 @@ def setup_sql_mod(dbapi_connection):
 event.listen(Pool,'connect',setup_sql_mod)
 event.listen(Pool,'connect',setup_sql_mod)
 event.listen(Pool,'first_connect',setup_sql_mod)
 event.listen(Pool,'first_connect',setup_sql_mod)
 
 
-class Open_Api(QAxWidget):
+class open_api(QAxWidget):
     def __init__(self):
     def __init__(self):
         super().__init__()
         super().__init__()