from PyQt5.QtCore import *
from PyQt5.QAxContainer import *
from PyQt5.QtWidgets import *
import datetime
from collections import defaultdict
from pandas import DataFrame
import re
import time

import warnings
warnings.simplefilter(action='ignore',category=UserWarning)

from sqlalchemy import create_engine,event,Text,Float
from sqlalchemy.pool import Pool
import pymysql
pymysql.install_as_MySQLdb()

from library.Logger import *
import library.cf
from library.simulator_api import *

# open_api에 tr요청을 보낼 때, 연속해서 보내면 오류가 발생하기 때문에 중간에 interval을 줘야 한다.
TR_REQ_TIME_INTERVAL=0.5            # interval값을 저장하는 변수
code_pattern=re.compile(r'\d{6}')   # 코드 패턴을 저장. 코드는 연속된 6자리의 숫자


# query문의 %를 %%로 변환하는 함수
def escape_percentage(conn,clauseelement,multiparmas,parmas):
    if isinstance(clauseelement,str) and '%' in clauseelement and multiparmas is not None:
        while True:
            replaced=re.sub(r'([^%])%([^%])', r'\1%%\2', clauseelement)
            if replaced==clauseelement:
                break
            clauseelement=replaced
    return clauseelement,multiparmas,parmas


# MySQL의 default sql_mode 설정
def setup_sql_mod(dbapi_connection,connection_record):
    cursor=dbapi_connection.cursor()
    cursor.execute("SET sql_mode=''")


event.listen(Pool,'connect',setup_sql_mod)
event.listen(Pool,'first_connect',setup_sql_mod)


# 키움증권 open_api를 사용하기 위한 클래스
class open_api(QAxWidget):
    def __init__(self):
        super().__init__()

        # event_loop list
        self.login_event_loop=QEventLoop()
        self.tr_event_loop=QEventLoop()

        # open_api 호출 횟수를 저장
        self.rq_count=0
        self.tr_loop_count=0
        self.call_time=datetime.datetime.now()

        # 날짜 설정
        self.date_setting()

        # open_api 연동
        self._create_open_api_instance()
        self._set_signal_slots()
        self.comm_connect()

        # 계좌정보 출력
        self.account_info()

        # 변수 설정
        self.variable_setting()

        self.sf=simulator_api(self.simul_num,"real",self.db_name)
        logger.debug("알고리즘 번호 : %s", self.sf.simul_num)
        logger.debug("다음날 매수종목 선택 알고리즘 번호 : %s", self.sf.db_to_realtime_daily_buy_list_num)
        logger.debug("매도 알고리즘 번호 : %s", self.sf.sell_list_num)
        
        # 시뮬레이션 데이터베이스에 setting_data 테이블이 존재하지 않는다면 생성
        if not self.sf.is_simul_table_exist(self.db_name,"setting_data"):
            self.init_db_setting_data()
        else:
            logger.debug("setting_data 테이블이 존재합니다.")

        # invest unit 설정
        self.sf_variable_setting()
        self.ohlcv=defaultdict(list)        # o(open)h(high)l(low)c(close)v(volume)를 저장하는 데이터프레임 변수

    # 오늘 날짜를 저장하는 함수
    def date_setting(self):
        self.today=datetime.datetime.today().strftime("%Y%m%d")                 # 년월일
        self.today_detail=datetime.datetime.today().strftime("%Y%m%d%H%M")      # 년월일시분

    # 키움 open_api 를 사용하기 위한 ocx controller 생성 함수
    def _create_open_api_instance(self):
        try:
            self.setControl("KHOPENAPI.KHOpenAPICtrl.1")
        except Exception as e:
            logger.critical(e)

    # 이벤트 처리를 위한 slots 연동 함수
    def _set_signal_slots(self):
        try:
            # 로그인 처리 이벤트
            self.OnEventConnect.connect(self._login_slot)
            # 조회요청 처리 이벤트
            self.OnReceiveTrData.connect(self._receive_tr_data)
            # 서버 통신 후 수신메세지 처리 이벤트
            self.OnReceiveMsg.connect(self._receive_msg)
            # 주문요청 처리 이벤트
            self.OnReceiveChejanData.connect(self._receive_chejan_data)
        except Exception as e:
            logger.critical(e)

    # 로그인 이벤트 처리 slot
    # param : code - 로그인 성공 시 0
    #                      실패 시 에러코드 출력
    def _login_slot(self,code):
        try:
            if code==0:
                logger.debug("connected")
            else:
                logger.debug("connection failed...")
            self.login_event_loop.exit()
        except Exception as e:
            logger.critical(e)

    # 사용자의 계좌정보 저장 및 출력
    def account_info(self):
        logger.debug("-* get_account_info 함수 *-")
        account_no=self.get_login_info("ACCNO")
        self.account_no=account_no.split(";")[0]
        logger.debug("계좌번호 : "+ self.account_no)

    # 원하는 사용자 정보 반환
    # param     :   tag - ACCNO - 보유계좌리스트
    #                     ACCOUNT_CNT - 보유계좌 수
    #                     USER_ID - 사용자 ID
    #                     USER_NAME - 사용자 이름
    #                     KEY_BSECGB - 키보드 보안 해제 여부 (0 : 정상, 1: 해지)
    #                     FIREW_SECGB - 방화벽 설정여부 (0 : 미설정, 1: 설정, 2 : 해지)
    #                     GetServerGubun - 접속서버 구분 (1 : 모의투자, 나머지 : 실서버)
    # return    :   tag를 통해 요청한 정보(ret) 반환
    def get_login_info(self,tag):
        try:
            ret=self.dynamicCall("GetLoginInfo(QString)",tag)
            return ret
        except Exception as e:
            logger.critical(e)

    # 수동 로그인설정인 경우 로그인창을 출력해서 로그인을 시도
    # 자동로그인 설정인 경우 로그인창 출력없이 로그인을 시도
    def comm_connect(self):
        try:
            self.dynamicCall("CommConnect()")
            self.login_event_loop.exec_()
        except Exception as e:
            logger.critical(e)

    # TR 요청을 처리하는 slot
    # param sScrNo      : 스크린번호
    #       sRQName     : 요청했을 때 지은 이름
    #       sTrCode     : 요청 id, tr코드
    #       sRecordName : 레코드 이름
    #       sPrevNext   : 다음 페이지가 있는지 여부. "2" : 다음페이지 존재, "0" or "" : 다음페이지 없음
    def _receive_tr_data(self,sScrNo,sRQName,sTrCode,sRecordName,sPrevNext):
        if sPrevNext=='2':
            self.remained_data=True     # 다음 페이지가 존재하는지 확인하는 변수
        else:
            self.remained_data=False

        # Request 요청에 따른 함수 처리
        if sRQName == "opt10081_req" and self.py_gubun == "trader":
            logger.debug("주식일봉차트조회요청")
            self._opt10081(sRQName,sTrCode)
        elif sRQName == "opt10081_req" and self.py_gubun == "collector":
            logger.debug("주식일봉차트조회요청")
            self.collector_opt10081(sRQName,sTrCode)
        elif sRQName == "opw00001_req":
            logger.debug("예수금상세현황요청")
            self._opw00001(sRQName,sTrCode)
        elif sRQName == "opw00018_req":
            logger.debug("계좌평가잔고내역요청")
            self._opw00018(sRQName,sTrCode)
        elif sRQName == "opt10074_req":
            logger.debug("일자별실현손익요청")
            self._opt10074(sRQName,sTrCode)
        elif sRQName == "opw00015_req":
            logger.debug("위탁종합거래내역요청")
            self._opw00015(sRQName,sTrCode)
        elif sRQName == "opt10076_req":
            logger.debug("실시간체결요청")
            self._opt10076(sRQName,sTrCode)
        elif sRQName == "opt10073_req":
            logger.debug("일자별종목별실현손익요청")
            self._opt10073(sRQName,sTrCode)
        elif sRQName == "opt10080_req":
            logger.debug("주식분봉차트조회요청")
            self._opt10080(sRQName,sTrCode)
        elif sRQName == "send_order_req":
            pass
        else:
            logger.debug("Invalid Request Code...")

        # 다음 페이지가 존재할 경우 처리
        # 다음 페이지가 존재하지 않을 경우 event loop를 종료
        if sRQName!="send_order_req":
            self.tr_loop_count-=1
        try:
            if self.tr_loop_count<=0:
                self.tr_event_loop.exit()
                self.tr_loop_count=0
        except AttributeError:
            pass

    # 서버통신 후 수신한 메시지를 알려주는 slot
    def _receive_msg(self,sScrNo,sRQName,sTrCode,sMsg):
        logger.debug(sMsg)

    # 주문요청후 주문접수, 체결통보, 잔고통보를 수신할 때 마다 호출
    # GetChejanData()함수를 이용해서 상세한 정보를 얻을 수 있다
    # param     :   sGubun  -   체결구분. 접수와 체결시 '0'값, 국내주식 잔고전달은 '1'값, 파생잔고 전달은 '4'
    def _receive_chejan_data(self,sGubun,nItemCnt,sFIdList):
        # 체결구분. 접수와 체결
        if sGubun=="0":
            code = code_pattern.search(self.get_chejan_data(9001)).group(0)  # 주식 코드가 숫자만오지 않아서 정규식으로 필터링
            order_num = self.get_chejan_data(9203)                           # 주문번호
            if not order_num:
                logger.debug(f'{code} 주문 실패')
                return

            chegyul_fail_amount=self.get_chejan_data(902)   # 미체결 수량
            order_gubun=self.get_chejan_data(905)           # 주문구분 (+매수 / -매도)
            purchase_price=self.get_chejan_data(10)         # 체결가

            # 종목코드가 존재한다면
            if code:
                if chegyul_fail_amount!="":
                    # 해당 종목을 보유하고 있지 않은 경우
                    if not self.is_all_stocks_db_check(code):
                        # 해당 종목의 체결 실패 내역이 없다면
                        # all_stocks 테이블에 업데이트. 정상 체결 시 chegyul_check=0
                        if chegyul_fail_amount=="0":
                            logger.debug(code, "체결 완료")
                            self.db_to_all_stocks(order_num,code,0,purchase_price,0)
                        # 체결 실패 내역이 존재한다면
                        # all_stocks 테이블에 업데이트. 미체결 시 chegyul_check=1
                        else:
                            logger.debug(code,"미체결")
                            self.db_to_all_stocks(order_num,code,1,purchase_price,0)

                    # 매수하는 경우
                    elif order_gubun=="+매수":
                        if chegyul_fail_amount!="0" and self.stock_chegyul_check(code):
                            logger.debug("미체결. 매수 진행중!")
                            pass
                        elif chegyul_fail_amount=="0" and self.stock_chegyul_check(code):
                            logger.debug("매수 완료")
                            self.end_invest_count_check(code)
                        else:
                            pass

                    # 매도하는 경우
                    elif order_gubun=="-매도":
                        if chegyul_fail_amount=="0":
                            logger.debug("전량 매도")
                            self.sell_final_check(code)
                        else:
                            logger.debug("부분 매도")
                            self.sell_chegyul_fail_check(code)

                    else:
                        logger.debug("Invalid order_gubun")
                else:
                    logger.debug("Invalid chegyul_fail_amount value")
            else:
                logger.debug("can't receive code value from get_chejan_data(9001)")

        # 국내주식 잔고전달
        elif sGubun=="1":
            chegyul_fail_amount=self.get_chejan_data(902)
            logger.debug("미체결 수량",chegyul_fail_amount)

        else:
            logger.debug("Invlid _receive_chejan_data")

    # 해당 종목이 체결되었는지 확인하는 함수
    # 미체결 항목이 존재하면 True를 반환
    def stock_chegyul_check(self,code):
        query = f"SELECT chegyul_check FROM all_stocks " \
                f"where code='{code}' and sell_date = '0' ORDER BY buy_date desc LIMIT 1"
        result = self.engine_bot.execute(query).fetchall()
        if result[0][0] == 1:
            return True
        else:
            return False

    # 매도 완료 후 DB 업데이트
    def sell_final_check(self,code):
        query="select valuation_profit,rate,item_total_purchase,present_price" \
              "from possessed_item" \
              "where code={} limit 1"
        get_list=self.engine_bot.execute(query.format(code)).fetchall()

        # 매도 완료 종목에 대해 DB 업데이트
        if get_list:
            item = get_list[0]
            query = f"""UPDATE all_stocks
                    SET 
                    item_total_purchase = {item.item_total_purchase}, chegyul_check = 0,
                    sell_date = '{self.today_detail}', valuation_profit = {item.valuation_profit},
                    sell_rate = {item.rate}, sell_price = {item.present_price}
                    WHERE code = '{code}' and sell_date = '0' ORDER BY buy_date desc LIMIT 1"""
            self.engine_bot.execute(query)

            # 매도 완료 후 possessd_item 테이블에서 해당 종목 삭제
            self.engine_bot.execute(f"DELETE FROM possessed_item WHERE code = '{code}'")
        else:
            logger.debug("보유 종목이 없습니다.")

    # 매도 체결 실패시 DB 업데이트
    def sell_chegyul_fail_check(self,code):
        query = f"UPDATE all_stocks SET chegyul_check='1' WHERE code='{code}' and sell_date = '0' " \
                f"ORDER BY buy_date desc LIMIT 1"
        self.engine_JB.execute(query)

    # OnReceiveChejan()이벤트가 호출될때 체결정보나 잔고정보를 얻어오는 함수
    # param     :   nFid    -   실시간 타입에 포함된 FID
    # FID List
    # (FID, 설명) : (9023, 주문번호), (302, 종목명), (900, 주문수량), (901,주문가격), (902,미체결수량), (904,원주문번호),
    #              (905, 주문구분), (908, 주문/체결시간), (909, 체결번호), (910, 체결가), (911, 체결량), (10, 현재가/체결가/실시간종가)
    def get_chejan_data(self,nFid):
        try:
            ret=self.dynamicCall("GetChejanData(int)",nFid)
            return ret
        except Exception as e:
            logger.critical(e)

    # 거래이력(all_stocks)테이블에 현재 보유중인 종목이 있는지 확인하는 함수
    # 보유한 종목이 있는 경우 True 반환
    def is_all_stocks_db_check(self,code):
        query = "select code from all_stocks " \
                "where code='%s' and (sell_date ='%s' or sell_date='%s') ORDER BY buy_date desc LIMIT 1"
        rows = self.engine_bot.execute(query % (code, 0, "")).fetchall()
        if len(rows) != 0:
            return True
        else:
            return False

    # 조회요청시 TR의 Input값을 지정하는 함수
    # param : sId       -   TR에 명시된 Input이름
    #         svalue    -   Input이름으로 지정한 값
    def set_input_value(self,sId,sValue):
        try:
            self.dynamicCall("SetInputValue(QString, QString)", sId, sValue)
        except Exception as e:
            logger.critical(e)

    # 조회요청함수
    # param : sRQName       -   사용자 구분명
    #         sTrCode       -   조회하려는 TR이름
    #         nPrevNext     -   연속조회여부
    #         sScreenNo     -   화면번호
    def comm_rq_data(self,sRQName,sTrData,nPrevNext,sScrNo):
        self.exit_check()
        ret=self.dynamicCall("CommRqData(QString, QString, int, QString", sRQName, sTrData, nPrevNext, sScrNo)
        if ret==-200:
            logger.critical("요청 제한 횟수 초과")

        self.call_time=datetime.datetime.now()

        if ret==0:
            self.tr_loop_count+=1
            self.tr_event_loop.exec_()

    # OnReceiveTRData()이벤트가 호출될때 조회데이터를 얻어오는 함수
    # param : sTrCode       -   TR 이름
    #         sRecordName   -   레코드이름
    #         nIndex        -   TR반복부
    #         sItemName     -   TR에서 얻어오려는 출력항목이름
    def _get_comm_data(self,sTrCode,sRecordName,nIndex,sItemName):
        ret = self.dynamicCall("GetCommData(QString, QString, int, QString", sTrCode, sRecordName, nIndex, sItemName)
        return ret.strip()

    # 조회수신한 멀티데이터의 갯수(반복)을 얻는다
    # param : sTrCode       -   tr이름
    #         sRecordName   -   레코드 이름
    def _get_repeat_cnt(self,sTrCode,sRecordName):
        try:
            ret=self.dynamicCall("GetRepeatCnt(QString, QString)",sTrCode,sRecordName)
            return ret
        except Exception as e:
            logger.critical(e)

    # 변수 설정
    # 실전투자인지 모의투자인지 여부를 확인하고 그에 해당하는 데이터베이스를 생성하는 함수
    def variable_setting(self):
        logger.debug("-* set variable 함수 *-")
        self.cf=library.cf
        self.get_today_buy_list_code=0
        self.reset_opw00018_output()

        if self.account_no==self.cf.real_account_no:
            logger.debug("실전투자 - 계좌번호 : "+self.account_no)
            self.simul_num=self.cf.real_num
            self.db_name_setting(self.cf.real_bot_name)
            self.mod_gubun=100      # 실전투자와 모의투자를 구분하는 변수

        elif self.account_no==self.cf.test_account_no:
            logger.debug("모의투자 - 계좌번호 : "+self.account_no)
            self.simul_num=self.cf.test_num
            self.db_name_setting(self.cf.test_bot_name)
            self.mod_gubun=1

        else:
            logger.debug("Invalid Account Number. Check the Config.py")
            exit(1)

        self.jango_is_null=True     # 더이상 투자할 금액이 남았는지 확인하는 변수
        self.py_gubun=False         # collector/trader을 구분하는 변수

    # 데이터베이스 생성 및 엔진 설정
    def db_name_setting(self,db_name):
        self.db_name=db_name
        conn=pymysql.connect(
            host=self.cf.db_ip,
            port=int(self.cf.db_port),
            user=self.cf.db_id,
            password=self.cf.db_pw,
            charset='utf8mb4',
            cursorclass=pymysql.cursors.DictCursor
        )
        with conn.cursor() as cursor:
            if not self.is_database_exist(cursor):
                self.create_database(cursor)
            self.engine_bot = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" +
                                            self.cf.db_ip + ":" + self.cf.db_port + "/" + db_name, encoding='utf-8')
            self.basic_db_check(cursor)

        conn.commit()
        conn.close()

        self.engine_craw = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                         self.cf.db_port + "/min_craw",encoding='utf-8')
        self.engine_daily_craw = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                               self.cf.db_port + "/daily_craw",encoding='utf-8')
        self.engine_daily_buy_list = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":"
                                                   + self.cf.db_port + "/daily_buy_list",encoding='utf-8')

        event.listen(self.engine_craw,'before_execute',escape_percentage,retval=True)
        event.listen(self.engine_daily_craw,'before_execute',escape_percentage,retval=True)
        event.listen(self.engine_daily_buy_list,'before_execute',escape_percentage,retval=True)

    # bot database가 존재하는지 확인하는 함수
    def is_database_exist(self,cursor):
        query=f"select 1 from information_schema.schemata where schema_name='{self.db_name}'"
        result=cursor.execute(query)
        if result:
            return True
        else:
            return False

    # bot database를 생성하는 함수
    def create_database(self,cursor):
        query=f"create database {self.db_name}"
        cursor.execute(query)

    # daily_craw(종목의 날짜별 데이터), daily_buy_list(날짜별 종목 데이터), min_craw(종목의 분별 데이터) 가 존재하는지 확인하는 함수
    # 존재하지 않는다면 새로 생성
    def basic_db_check(self,cursor):
        check_list = ['daily_craw', 'daily_buy_list', 'min_craw']
        query = "SELECT SCHEMA_NAME FROM information_schema.SCHEMATA"
        cursor.execute(query)
        result = cursor.fetchall()
        db_list = [n['SCHEMA_NAME'].lower() for n in result]
        create_db_query = "CREATE DATABASE {}"
        has_created = False
        for check_name in check_list:
            if check_name not in db_list:
                has_created = True
                logger.debug(f"{check_name} 데이터베이스 생성...")
                cursor.execute(create_db_query.format(check_name))

        if has_created and self.engine_bot.has_table('setting_data'):
            self.engine_bot.execute("UPDATE setting_data SET code_update = '0'")

    # setting_data 테이블 생성 및 초기화하는 함수
    def init_db_setting_data(self):
        logger.debug("-* init_setting_data 함수 *-")

        df_setting_data_temp = {'limit_money': [], 'invest_unit': [], 'max_invest_unit': [],
                                'min_invest_unit': [],'set_invest_unit': [], 'code_update': [],
                                'today_buy_stop': [],'jango_data_db_check': [], 'possessed_item': [],
                                'today_profit': [],'final_chegyul_check': [],'db_to_buy_list': [], 'today_buy_list': [],
                                'daily_crawler': [],'daily_buy_list': []}

        df_setting_data = DataFrame(df_setting_data_temp,
                                    columns=['limit_money', 'invest_unit', 'max_invest_unit','min_invest_unit',
                                             'set_invest_unit', 'code_update', 'today_buy_stop',
                                             'jango_data_db_check', 'possessed_item', 'today_profit',
                                             'final_chegyul_check','db_to_buy_list', 'today_buy_list', 'daily_crawler',
                                             'daily_buy_list'])

        # 칼럼 자료형 설정
        df_setting_data.loc[0, 'limit_money'] = int(0)                      # 잔고에 최소한으로 남겨놓을 금액
        df_setting_data.loc[0, 'invest_unit'] = int(0)                      # 기준 투자금액
        df_setting_data.loc[0, 'max_invest_unit'] = int(0)                  # 최대 투자금액
        df_setting_data.loc[0, 'min_invest_unit'] = int(0)                  # 최소 투자금액
        df_setting_data.loc[0, 'set_invest_unit'] = str(0)                  # 기준 투자금액 설정 날짜

        df_setting_data.loc[0, 'code_update'] = str(0)                      # setting_data의 데이터를 업데이트 한 날짜
        df_setting_data.loc[0, 'today_buy_stop'] = str(0)                   # 당일 구매 종료 설정 시간
        df_setting_data.loc[0, 'jango_data_db_check'] = str(0)              # 잔고데이터 DB 업데이트 날짜
        df_setting_data.loc[0, 'possessed_item'] = str(0)                   # 보유종목 DB 업데이트 날짜
        df_setting_data.loc[0, 'today_profit'] = str(0)                     # 당일 수익

        df_setting_data.loc[0, 'final_chegyul_check'] = str(0)              # 마지막 체결 확인
        df_setting_data.loc[0, 'db_to_buy_list'] = str(0)                   # 구매 리스트 DB 업데이트 날짜
        df_setting_data.loc[0, 'today_buy_list'] = str(0)                   # 당일 구매 리스트 DB 업데이트 날짜
        df_setting_data.loc[0, 'daily_crawler'] = str(0)                    # daily_crawler(종목의 일별 데이터) 업데이트 날짜
        df_setting_data.loc[0, 'min_crawler'] = str(0)                      # min_crawler(종목의 분별 데이터) 업데이트 날자
        df_setting_data.loc[0, 'daily_buy_list'] = str(0)                   # daily_buy_list(일별 종목 데이터) 업데이트 날짜

        df_setting_data.to_sql('setting_data', self.engine_bot, if_exists='replace')

    # simulator_api 에서 설정한 변수를 가져오는 함수
    def sf_variable_setting(self):
        logger.debug("-* set simul variable function *-")
        # daily_buy_list에 저장된 가장 최신 날짜
        self.date_rows_yesterday=self.sf.get_recent_daily_buy_list_date()

        # AutoBot 데이터베이스에 all_stock 테이블이 존재하지 않을 경우 테이블 생성 및 초기화
        # all_stocks : 모든 주식 거래 내역을 저장하는 테이블
        if not self.sf.is_simul_table_exist(self.db_name,"all_stocks"):
            logger.debug("all_stocks 테이블을 생성합니다")
            # 테이블 생성 후 초기화
            self.invest_unit=0
            self.db_to_all_stocks(0,0,0,0,0)
            self.delete_all_stocks("0")

        # setting_data에 invest_unit값이 없다면 설정
        if not self.check_set_invest_unit():
            self.set_invest_unit()
        # 존재한다면 해당 값을 simulator_api에 저장
        else:
            self.invest_unit=self.get_invest_unit()
            self.sf.invest_unit=self.invest_unit

    # all_stock(거래 내역) 테이블 생성
    def db_to_all_stocks(self,order_num,code,chegyul_check,purchase_price,rate):
        logger.debug("-* db_to_all_stocks function *-")

        self.date_setting()
        self.sf.init_df_all_stocks()        # all_stocks 테이블 데이터프레임 생성

        # dataframe에 값 할당
        self.sf.df_all_stocks.loc[0, 'order_num'] = order_num                  # 주문번호
        self.sf.df_all_stocks.loc[0, 'code'] = str(code)                       # 종목코드
        self.sf.df_all_stocks.loc[0, 'rate'] = float(rate)                     # 수익률
        self.sf.df_all_stocks.loc[0, 'buy_date'] = self.today_detail           # 구매날짜
        self.sf.df_all_stocks.loc[0, 'chegyul_check'] = chegyul_check          # 체결확인

        self.sf.df_all_stocks.loc[0, 'invest_unit'] = self.invest_unit         # 투자기준금액
        self.sf.df_all_stocks.loc[0, 'purchase_price'] = purchase_price        # 구매금액

        # 신규매수
        if order_num != 0:
            recent_daily_buy_list_date=self.sf.get_recent_daily_buy_list_date()
            # 구매 내역이 존재하는 경우 해당 데이터를 추가
            if recent_daily_buy_list_date:
                # 특정 날짜, 특정 종목의 주가 데이터
                df=self.sf.get_daily_buy_list_by_code(code,recent_daily_buy_list_date)
                if not df.empty:
                    self.sf.df_all_stocks.loc[0, 'code_name'] = df.loc[0, 'code_name']     # 종목명

                    self.sf.df_all_stocks.loc[0, 'close'] = df.loc[0, 'close']             # 종가
                    self.sf.df_all_stocks.loc[0, 'open'] = df.loc[0, 'open']               # 시가
                    self.sf.df_all_stocks.loc[0, 'high'] = df.loc[0, 'high']               # 고가
                    self.sf.df_all_stocks.loc[0, 'low'] = df.loc[0, 'low']                 # 저가
                    self.sf.df_all_stocks.loc[0, 'volume'] = df.loc[0, 'volume']           # 거래량

                    self.sf.df_all_stocks.loc[0,'d1_diff']=float(df.loc[0,'d1_diff'])      # 전날대비 가격변동
                    self.sf.df_all_stocks.loc[0, 'd1_diff_rate'] = float(df.loc[0, 'd1_diff_rate'])    # 전날대비 가격변동률

                    self.sf.df_all_stocks.loc[0, 'clo5'] = df.loc[0, 'clo5']               # 5일 이동평균선
                    self.sf.df_all_stocks.loc[0, 'clo10'] = df.loc[0, 'clo10']             # 10일 이동평균선
                    self.sf.df_all_stocks.loc[0, 'clo20'] = df.loc[0, 'clo20']             # 20일 이동평균선
                    self.sf.df_all_stocks.loc[0, 'clo60'] = df.loc[0, 'clo60']             # 60일 이동평균선
                    self.sf.df_all_stocks.loc[0, 'clo120'] = df.loc[0, 'clo120']           # 120일 이동평균선

                    if df.loc[0, 'clo5_diff_rate'] is not None:
                        self.sf.df_all_stocks.loc[0, 'clo5_diff_rate'] = float(df.loc[0, 'clo5_diff_rate'])        # 5일 이동평균선 변동률
                    if df.loc[0, 'clo10_diff_rate'] is not None:
                        self.sf.df_all_stocks.loc[0, 'clo10_diff_rate'] = float(df.loc[0, 'clo10_diff_rate'])
                    if df.loc[0, 'clo20_diff_rate'] is not None:
                        self.sf.df_all_stocks.loc[0, 'clo20_diff_rate'] = float(df.loc[0, 'clo20_diff_rate'])
                    if df.loc[0, 'clo60_diff_rate'] is not None:
                        self.sf.df_all_stocks.loc[0, 'clo60_diff_rate'] = float(df.loc[0, 'clo60_diff_rate'])
                    if df.loc[0, 'clo120_diff_rate'] is not None:
                        self.sf.df_all_stocks.loc[0, 'clo120_diff_rate'] = float(df.loc[0, 'clo120_diff_rate'])

        self.sf.df_all_stocks = self.sf.df_all_stocks.fillna(0)         # null값을 0으로 변환
        self.sf.df_all_stocks.to_sql('all_stocks', self.engine_bot, if_exists='append', dtype={
            'code_name': Text,
            'rate': Float,
            'sell_rate': Float,
            'purchase_rate': Float,
            'sell_date': Text,
            'd1_diff': Integer,
            'd1_diff_rate': Float,
            'clo5_diff_rate': Float,
            'clo10_diff_rate': Float,
            'clo20_diff_rate': Float,
            'clo60_diff_rate': Float,
            'clo120_diff_rate': Float,
        })

    # all_stocks(거래내역) 테이블에서 특정 종목을 삭제하는 함수
    def delete_all_stocks(self,code):
        query=f"delete from all_stocks where code={code}"
        self.engine_bot.execute(query)

    # setting_data 테이블에 invest_unit이 오늘 업데이트 되었는지 확인
    def check_set_invest_unit(self):
        query="select invest_unit,set_invest_unit from setting_data limit 1"
        result=self.engine_bot.execute(query).fetchall()
        if result[0][1]==self.today:
            self.invest_unit=result[0][0]
            return True
        else:
            return False

    # 데이터베이스에서 invest_unit값을 가져오는 함수
    def get_invest_unit(self):
        logger.debug("-* get_invest_unit function *-")
        query="select invest_unit from setting_data limit 1"
        result=self.engine_bot.execute(query).fetchall()
        return result[0][0]

    # invest_unit 항목 업데이트
    # 업데이트 완료 후 set_invest_unit에 업데이트 날짜 저장
    def set_invest_unit(self):
        self.get_d2_deposit()
        self.check_balance()
        self.total_invest=self.change_format(str(int(self.d2_deposit_before_format)+int(self.total_purchase_price)))

        self.invest_unit=self.sf.invest_unit
        query=f"update setting_data set invest_unit='{self.invest_unit}', set_invest_unit='{self.today}'"
        self.engine_bot.execute(query)

    # 예수금 조회 및 저장
    def get_d2_deposit(self):
        self.set_input_value("계좌번호",self.account_no)
        self.set_input_value("비밀번호입력매체구분",00)
        self.set_input_value("조회구분",1)
        self.comm_rq_data("opw00001_req","opw00001",0,"2000")

    # 잔고 조회 및 저장
    def check_balance(self):
        self.reset_opw00018_output()

        self.set_input_value("계좌번호",self.account_no)
        self.comm_rq_data("opw00018_req","opw00018",0,"2000")
        # 다음페이지가 존재할 경우 계속해서 조회
        while self.remained_data:
            self.set_input_value("계좌번호",self.account_no)
            self.comm_rq_data("opw00018_req","opw00018",2,"2000")

    # open_api를 통해 보유한 종목을 가져오는 함수
    # 가져온 정보를 possessed_item이라는 테이블에 저장
    def db_to_possessed_item(self):
        item_count=len(self.opw00018_output['multi'])
        possessed_item_data={'date':[],'code':[],'code_name':[],'holding_amount':[],'purchase_price':[],
                             'present_price':[],'valuation_profit':[],'rate':[],'item_total_purchase':[]}

        possessed_item=DataFrame(possessed_item_data,
                                 columns=['date','code','code_name','holding_amount','purchase_price',
                                          'present_price','valuation_profit','rate','item_total_purchase'])

        for i in range(item_count):
            item=self.opw00018_output['multi'][i]

            possessed_item.loc[i,'date']=self.today
            possessed_item.loc[i,'code']=item[7]
            possessed_item.loc[i,'code_name']=item[0]
            possessed_item.loc[i,'holding_amount']=int(item[1])         # 보유량
            possessed_item.loc[i,'purchase_price']=int(item[2])         # 매수가
            possessed_item.loc[i,'present_price']=int(item[3])          # 현재가
            possessed_item.loc[i,'valuation_profit']=int(item[4])       # 평가수익률
            possessed_item.loc[i,'rate']=float(item[5])                 # 수익률
            possessed_item.loc[i,'item_total_purchase']=int(item[6])    # 총매수금액

        possessed_item.to_sql("possessed_item",self.engine_bot,if_exists='replace')
        self.chegyul_sync()

    # 매수 완료한 항목을 all_stocks에 기록하는 함수
    def chegyul_sync(self):
        # 신규 매수한 항목을 가져온다
        query = "select code, code_name, rate from possessed_item p " \
                "where p.code not in (select a.code from all_stocks a where a.sell_date = '0' group by a.code) " \
                "group by p.code"
        result=self.engine_bot.execute(query).fetchall()

        for item in result:
            self.set_input_value("종목코드",item.code)
            self.set_input_value("조회구분",1)
            self.set_input_value("계좌번호",self.account_no)
            self.comm_rq_data("opt10076_req","opt10076",0,"0350")

            if self._data['주문구분']=='+매수':
                if self._data['미체결수량']==0:
                    chegyul_check=0
                else:
                    chegyul_check=1
            elif self._data['주문구분']=='':
                self.db_to_all_stocks(self.today,item.code,0,0,item.rate)
                continue
            else:
                continue

            self.db_to_all_stocks(self._data['주문번호'],item.code,chegyul_check,self._data['체결가'],item.rate)

    # setting_data에 possessed_item 항목을 업데이트
    def setting_data_possessed_item(self):
        query=f"update setting_data set possessed_item={self.today} limit 1"
        self.engine_bot.execute(query)

    # 특정 종목의 일자별 거래 데이터 조회 함수
    def get_total_data(self,code,code_name,date):
        self.ohlcv=defaultdict(list)
        self.set_input_value("종목코드",code)
        self.set_input_value("기준일자",date)
        self.set_input_value("수정주가구분",1)

        # 한번에 600일치의 데이터를 가져온다
        self.comm_rq_data("opt10081_req","opt10081",0,"0101")

        #  종목 테이블이 존재하지 않는다면 600일치 이상의 전체 데이터를 가져와야 하므로 다음 페이지가 존재하지 않을 때까지 조회
        if not self.is_craw_table_exist(code_name):
            while self.remained_data==True:
                self.set_input_value("종목코드",code)
                self.set_input_value("기준일자",date)
                self.set_input_value("수정주가구분",1)
                self.comm_rq_data("opt10081_req","opt10081",2,"0101")

        if len(self.ohlcv)==0:
            return []
        if self.ohlcv['date']=='':
            return []

        df=DataFrame(self.ohlcv,columns=['date','open','high','low','close','volume'])

        return df

    # daily_craw 데이터베이스에 종목 테이블이 존재하는지 확인하는 함수
    def is_craw_table_exist(self,code_name):
        query = "select 1 from information_schema.tables where table_schema ='daily_craw' and table_name = '{}'"
        result=self.engine_daily_craw.execute(query.format(code_name)).fetchall()
        if result:
            return True
        else:
            return False

    # daily_craw의 특정 종목 테이블에서 마지막으로 저장된 날짜를 가져오는 함수
    # 저장된 데이터가 없다면 '0'문자를 반환
    def get_daily_craw_db_last_date(self,code_name):
        query="select date from {} order by date desc limit 1"
        result=self.engine_daily_craw.execute(query.format(code_name)).fetchall()
        if len(result):
            return result[0][0]
        else:
            return str(0)

    # 체결이 완료되었는지 확인하고 all_stocks(거래내역)테이블을 업데이트
    def check_chegyul(self):
        query="select code from all_stocks where chegyul_check='1' and (sell_date='0' or sell_date='')"
        result=self.engine_bot.execute(query).fetchall()

        for r in result:
            self.set_input_value("종목코드",r.code)
            self.set_input_value("조회구분",1)
            self.set_input_value("계좌번호",self.account_no)
            self.comm_rq_data("opt10076_req","opt10076",0,"0350")

            query=f"update all_stocks set chegyul_check='0' where code='{r.code}' and sell_data='0' " \
                  f"order by buy_date desc limit 1"
            # 과거에 거래한 내역이 존재하는 경우 opt10076 조회 시 주문번호 등의 데이터가 존재하지 않음
            # 거래가 완료된 항목에 대해서 contract_check항목을 '0'으로 업데이트
            if not self._data['주문번호']:
                self.engine_bot.execute(query)
            # 미체결 수량이 없을 경우 contract_check항목을 '0'으로 업데이트
            elif self._data['미체결수량']==0:
                logger.debug("미체결 항목이 없습니다")
                self.engine_bot.execute(query)
            else:
                logger.debug("미체결 종목이 존재합니다")

    # 매도한 후, 보유종목(possessed_item) 내역과 거래내역(all_stocks) 내역의 데이터를 맞추는 함수
    # 거래내역 테이블에서 매도처리되지 않은 항목을 업데이트
    def sell_final_check2(self, code):
        query = "UPDATE all_stocks SET " \
                "chegyul_check='%s', sell_date ='%s' WHERE code='%s' and sell_date ='%s' ORDER BY buy_date desc LIMIT 1"

        self.engine_bot.execute(query % (0, self.today_detail, code, 0))

    # 매도했을 때, possessed_item에서 삭제되었지만 all_stocks에 sell_date 칼럼이 업데이트 되지 않은 항목들을 처리하는 함수
    def final_chegyul_check(self):
        query = "select code from all_stocks a " \
                "where (a.sell_date = '0' or a.sell_date ='') and a.code not in ( select code from possessed_item) "\
                "and a.chegyul_check != '1'"

        result = self.engine_bot.execute(query).fetchall()
        num = len(result)

        for t in range(num):
            self.sell_final_check2(result[t][0])

        # 모든 항목을 처리했으면 setting_data테이블의 final_chegyul_check 항목에 오늘 날짜를 저장
        query = f"UPDATE setting_data SET final_chegyul_check='{self.today}' limit 1"
        self.engine_bot.execute(query)

    # 현재 보유하고 있는 종목의 수를 반환하는 함수
    def get_count_possessed_item(self):
        query="select count(*) from possessed_item"
        result=self.engine_bot.execute(query).fetchall()
        return result[0][0]

    # 특정 종목의 틱(1분별) 데이터 조회 함수
    def get_total_data_min(self,code,code_name,start):
        self.ohlcv=defaultdict(list)

        self.set_input_value("종목코드",code)
        self.set_input_value("틱범위",1)
        self.set_input_value("수정주가구분",1)
        self.comm_rq_data("opt10080_req","opt10080",0,"1999")

        self.craw_table_exist=False

        if self.is_min_craw_table_exist(code_name):
            self.craw_table_exist=True
            self.craw_db_last_min=self.get_craw_db_last_min(code_name)
            self.craw_db_last_min_sum_volume=self.get_craw_db_last_min_sum_volume(code_name)

        else:
            self.craw_db_last_min=str(0)
            self.craw_db_last_min_sum_volume=0

        while self.remained_data:
            time.sleep(TR_REQ_TIME_INTERVAL)
            self.set_input_value("종목코드",code)
            self.set_input_value("틱범위",1)
            self.set_input_value("수정주가구분",1)
            self.comm_rq_data("opt10080_req","opt10080",2,"1999")

            if self.ohlcv['date'][-1] < self.craw_db_last_min:
                break
            """
            if self.craw_table_exist:
                if self.ohlcv['date'][-1]<self.craw_db_last_min:
                    break
            else:
                break
            """
        time.sleep(TR_REQ_TIME_INTERVAL)

        if len(self.ohlcv['date'])==0 or self.ohlcv['date'][0]=='':
            return []
        if self.ohlcv['date']=='':
            return []

        df = DataFrame(self.ohlcv, columns=['date', 'open', 'high', 'low', 'close', 'volume', 'sum_volume'])

        return df

    # min_craw 데이터베이스에 {code_name} 테이블이 존재하는지 확인하는 함수
    def is_min_craw_table_exist(self,code_name):
        query = "select 1 from information_schema.tables where table_schema ='min_craw' and table_name = '{}'"
        result = self.engine_craw.execute(query.format(code_name)).fetchall()
        if result:
            return True
        else:
            return False

    # min_craw 테이블에서 마지막에 저장한 행의 sum_volume값을 가져오는 함수
    def get_craw_db_last_min_sum_volume(self,code_name):
        query = f"SELECT sum_volume from `{code_name}` order by date desc limit 1"
        result = self.engine_craw.execute(query).fetchall()
        if len(result):
            return result[0][0]
        else:
            return str(0)

    # min_craw 테이블에서 마지막에 저장한 행의 시간(분) 정보를 가져오는 함수
    def get_craw_db_last_min(self,code_name):
        query = f"SELECT date from {code_name} order by date desc limit 1"
        result = self.engine_craw.execute(query).fetchall()
        if len(result):
            return result[0][0]
        # 신생
        else:
            return str(0)

    # 특정 종목의 특정 날짜의 특정 데이터(시가/종가/고가/저가/거래량)를 반환하는 함수
    def get_one_day_option_data(self,code,start,option):
        self.ohlcv=defaultdict(list)

        self.set_input_value("종목코드",code)
        self.set_input_value("기준일자",start)
        self.set_input_value("수정주가구분",1)
        self.comm_rq_data("opt10081_req","opt10081",0,"0101")

        if self.ohlcv['date']=='':
            return False

        df=DataFrame(self.ohlcv,columns=['open','high','low','close','volume'],index=self.ohlcv['date'])

        if df.empty:
            return False

        if option=="open":
            return df.iloc[0,0]
        elif option=='high':
            return df.iloc[0,1]
        elif option=='low':
            return df.iloc[0,2]
        elif option=='close':
            return df.iloc[0,3]
        elif option=='volume':
            return df.iloc[0,4]
        else:
            return False

    # open_api에 주문요청을 보내는 함수. 성공할 경우 return 0
    # param     -   sRQName         :   사용자 구분명
    #               sScrNo          :   화면번호
    #               sAccNo          :   계좌번호
    #               nOrderType      : 주문유형 (1.신규매수/2.신규매도/3.매수취소/4.매도취소/5.매수정정/6.매도정정
    #               code            : 종목코드
    #               nQty            : 주문수량
    #               nPrice          : 주문가격
    #               sHogaGb         : 거래구분 (00.지정가/03.시장가/05.조건부지정가/06.최유리지정가/07.최우선지정가/10.지정가IOC/
    #                                 13.시장가IOC/16.최유리IOC/20.지정가FOK/23.시장가FOK/26.최유리FOK/61.장전시간외종가
    #                                 62.시간외단일가매매/81.장후시간외종가)
    #               sOrgOrderNo     : 원주문번호. 신규주문은 공백, 정정(취소) 주문할 원주문번호 입력
    # return    -   0               : 성공
    #           -   -308            : 주문가능횟수 초과. 1초에 5회만 주문 가능
    #           -   이외              : 주문실패
    def send_order(self,sRQName,sScrNo,sAccNo,nOrderType,code,nQty,nPrice,sHogaGb,sOrgOrderNo):
        logger.debug("send order")
        try:
            self.exit_check()
            self.dynamicCall("SendOrder(QString, QString, QString, int, QString, int, int, QString, QString)",
                             [sRQName,sScrNo,sAccNo,nOrderType,code,nQty,nPrice,sHogaGb,sOrgOrderNo])
        except Exception as e:
            logger.critical(e)

    # 코드명에 해당하는 종목코드를 반환하는 함수
    def codename_to_code(self,codename):
        # 데이터베이스에 종목명과 같은 값을 가지는 행의 code를 반환
        query = f"select code from stock_item_all where code_name={codename}"
        result = self.engine_daily_buy_list.execute(query).fetchall()
        if len(result)!=0:
            return result[0][0]

        # 종목명의 길이가 길 경우
        query = f"select code from stock_item_all where code_name like '{codename}%'"
        result = self.engine_daily_buy_list.execute(query).fetchall()
        if len(result)!=0:
            return result[0][0]

        # 종목명에 해당하는 값이 없을 경우 return False
        return False

    # 매수 완료 후 데이터베이스를 업데이트 하는 함수
    def end_invest_count_check(self,code):
        query = f"update all_stocks set chegyul_check='0' WHERE code='{code}' and sell_date = '0' " \
                f"ORDER BY buy_date desc LIMIT 1"
        self.engine_bot.execute(query)

        # possessed_item 테이블에 중복으로 데이터가 반영되는 것을 막기 위해 possessed_item에서 해당 종목 삭제
        query = f"delete from possessed_item where code ='{code}'"
        self.engine_bot.execute(query)

    # 잔액이 생겨서 다시 매수할 수 있는 상황이 되었을 경우, setting_data의 today_buy_stop 옵션을 0으로 변경
    def buy_check_reset(self):
        query = "UPDATE setting_data SET today_buy_stop='0' WHERE id='1'"
        self.engine_bot.execute(query)

    # 투자 가능한 잔액이 부족하거나, 매수할 종목이 더 이상 없는 경우 setting_data의 today_buy_stop 옵션을 당일 날짜로 변경
    # today_buy_stop!=0인 경우, 더이상 매수하지 않음
    def buy_check_stop(self):
        query = f"UPDATE setting_data SET today_buy_stop='{self.today}' limit 1"
        self.engine_bot.execute(query)

    # 잔액을 확인하는 함수
    # 잔액이 부족하여 더이상 투자를 진행할 수 없는 경우, jango_is_null을 True로 설정한 후 False 반환
    def jango_check(self):
        self.get_d2_deposit()
        try:
            if int(self.d2_deposit_before_format) > (int(self.sf.limit_money)):
                self.jango_is_null = False                  # trade 루프를 돌다가 잔액이 부족해졌을 때 루프를 빠져나오기 위한 변수
                return True
            else:
                self.jango_is_null = True
                return False
        except Exception as e:
            logger.critical(e)

    # today_buy_stop 칼럼을 확인하는 함수
    # setting_data 테이블의 today_buy_stop 칼럼에 오늘 날짜가 적혀있는 경우 매수 중지
    def buy_check(self):
        query = "select today_buy_stop from setting_data limit 1"
        result = self.engine_bot.execute(query).fetchall()[0][0]

        if result != self.today:
            return True
        else:
            return False

    # 구매할 수량을 계산하는 함수
    def buy_num_count(self,invest_unit,present_price):
        return int(invest_unit/present_price)

    # 매수 함수
    def trade(self):
        # 실시간 현재가(close)를 저장
        # 현재시점의 종가(close)는 현재가와 같다
        current_price = self.get_one_day_option_data(self.get_today_buy_list_code, self.today, 'close')

        if current_price == False:
            return False

        min_buy_limit = int(self.get_today_buy_list_close) * self.sf.invest_min_limit_rate      # 매수가격 최저 범위
        max_buy_limit = int(self.get_today_buy_list_close) * self.sf.invest_limit_rate          # 매수가격 최고 범위

        # 현재가가 매수 가격 최저 범위와 매수 가격 최고 범위 안에 들어와 있다면 매수
        if min_buy_limit < current_price < max_buy_limit:
            buy_num = self.buy_num_count(self.invest_unit, int(current_price))
            logger.debug(
                "매수 - code :%s, 목표가: %s, 현재가: %s, 매수량: %s, min_buy_limit: %s, max_buy_limit: %s , invest_limit_rate: %s,예수금: %s , today : %s, today_min : %s, date_rows_yesterday : %s, invest_unit : %s, real_invest_unit : %s",
                self.get_today_buy_list_code, self.get_today_buy_list_close, current_price, buy_num, min_buy_limit,
                max_buy_limit, self.sf.invest_limit_rate, self.d2_deposit_before_format, self.today, self.today_detail,
                self.date_rows_yesterday, self.invest_unit, int(current_price) * int(buy_num))

            # 03 시장가 매수
            # 4번째 parameter: 1: 신규매수 / 2: 신규매도 / 3:매수취소 / 4:매도취소 / 5: 매수정정 / 6:매도정정
            self.send_order("send_order_req", "0101", self.account_no, 1, self.get_today_buy_list_code, buy_num, 0,
                            "03", "")

            # 만약 sf.only_nine_buy가 False 이면, 매도 후에 잔액이 생기면 다시 매수를 시작
            # sf.only_nine_buy가 True이면 1회만 매수, 1회 매수 시 잔액이 부족해지면 바로 매수 중단
            if not self.jango_check() and self.sf.only_nine_buy:
                # setting_data에 today_buy_stop을 1 로 설정
                self.buy_check_stop()

    # 오늘 매수할 종목 리스트를 가져오는 함수
    def get_today_buy_list(self):
        # 구매할 목록을 저장하는 테이블(realtime_daily_buy_list)이 존재하지 않거나, 테이블 내에 항목이 존재하지 않는다면 return
        if self.sf.is_simul_table_exist(self.db_name, "realtime_daily_buy_list"):
            self.sf.get_realtime_daily_buy_list()
            if self.sf.len_df_realtime_daily_buy_list == 0:
                return
        else:
            return

        # 만약에 realtime_daily_buy_list 의 종목 수가 1개 이상이면
        for i in range(self.sf.len_df_realtime_daily_buy_list):
            code = self.sf.df_realtime_daily_buy_list.loc[i,'code']
            close = self.sf.df_realtime_daily_buy_list.loc[i, 'close']
            check_item = self.sf.df_realtime_daily_buy_list.loc[i, 'check_item']    # 매수확인. 오늘 매수한 종목이면 1, 아니면 0

            # 잔액이 부족한 경우 break
            if self.jango_is_null:
                break
            # 이미 매수한 종목은 건너뛰고 다음종목 거래래
            if check_item == True:
                continue
            else:
                self.get_today_buy_list_code = code
                self.get_today_buy_list_close = close
                # 매수 하기 전에 해당 종목의 check_item을 1로 변경
                query = f"UPDATE realtime_daily_buy_list SET check_item='1' WHERE code='{self.get_today_buy_list_code}'"
                self.engine_bot.execute(query)
                self.trade()

        # 모든 매수를 마쳤으면 더이상 매수 하지 않도록 설정
        if self.sf.only_nine_buy:
            self.buy_check_stop()

    # 보유하고 있는 종목에 대해 all_stocks(거래내역) 테이블의 rate(수익률) 관련 칼럼을 업데이트
    def rate_check(self):
        query = "select code,holding_amount,purchase_price,present_price,valuation_profit,rate,item_total_purchase "\
                "from possessed_item group by code"
        result=self.engine_bot.execute(query).fetchall()
        num = len(result)

        for k in range(num):
            code = result[k][0]
            holding_amount = result[k][1]
            purchase_price = result[k][2]
            present_price = result[k][3]
            valuation_profit = result[k][4]
            rate = result[k][5]
            item_total_purchase = result[k][6]

            query = f"update all_stocks set " \
                    f"holding_amount ='{holding_amount}', purchase_price ='{purchase_price}', " \
                    f"present_price='{present_price}',valuation_profit='{valuation_profit}',rate='{rate}'," \
                    f"item_total_purchase='{item_total_purchase}' " \
                    f"where code='{code}' and sell_date = '0'"
            self.engine_bot.execute(query)

    # 주식일봉차트조회 요청 함수 - 하나의 데이터만 저장
    def _opt10081(self, sRQName, sTrCode):
        code = self._get_comm_data(sTrCode, sRQName, 0, "종목코드")
        # 조회하는 종목이 매수하려는 종목이 아니라면 에러메세지 출력
        if code != self.get_today_buy_list_code:
            logger.critical(f"_opt10081:({code},{self.get_today_buy_list_code})")

        date = self._get_comm_data(sTrCode, sRQName, 0, "일자")
        open = self._get_comm_data(sTrCode, sRQName, 0, "시가")
        high = self._get_comm_data(sTrCode, sRQName, 0, "고가")
        low = self._get_comm_data(sTrCode, sRQName, 0, "저가")
        close = self._get_comm_data(sTrCode, sRQName, 0, "현재가")
        volume = self._get_comm_data(sTrCode, sRQName, 0, "거래량")

        self.ohlcv['date'].append(date)
        self.ohlcv['open'].append(int(open))
        self.ohlcv['high'].append(int(high))
        self.ohlcv['low'].append(int(low))
        self.ohlcv['close'].append(int(close))
        self.ohlcv['volume'].append(int(volume))

    # 주식일봉차트조회 요청 함수 - 모든 행의 데이터를 저장
    def collector_opt10081(self, sRQName, sTrCode):
        # 몇개의 행을 읽어야 하는지 담는 변수
        ohlcv_cnt = self._get_repeat_cnt(sTrCode, sRQName)

        for i in range(ohlcv_cnt):
            date = self._get_comm_data(sTrCode, sRQName, i, "일자")
            open = self._get_comm_data(sTrCode, sRQName, i, "시가")
            high = self._get_comm_data(sTrCode, sRQName, i, "고가")
            low = self._get_comm_data(sTrCode, sRQName, i, "저가")
            close = self._get_comm_data(sTrCode, sRQName, i, "현재가")
            volume = self._get_comm_data(sTrCode, sRQName, i, "거래량")

            self.ohlcv['date'].append(date)
            self.ohlcv['open'].append(int(open))
            self.ohlcv['high'].append(int(high))
            self.ohlcv['low'].append(int(low))
            self.ohlcv['close'].append(int(close))
            self.ohlcv['volume'].append(int(volume))

    # 예수금 상세현황요청 함수
    def _opw00001(self,sRQName,sTrCode):
        try:
            self.d2_deposit_before_format = self._get_comm_data(sTrCode, sRQName, 0, "d+2출금가능금액")
            self.d2_deposit = self.change_format(self.d2_deposit_before_format)
        except Exception as e:
            logger.critical(e)

    # 계좌평가 잔고내역을 저장하는 변수 초기화
    def reset_opw00018_output(self):
        # single data : 계좌에 대한 평가 잔고 데이터 제공
        # multi data  : 보유 종목별 평가 잔고 데이터 제공
        self.opw00018_output={'single':[],'multi':[]}

    # 계좌평가 잔고내역 요청 함수
    def _opw00018(self,sRQName,sTrCode):
        # 계좌평가 잔고 데이터 - 싱글데이터 저장
        self.total_purchase_price=self._get_comm_data(sTrCode,sRQName,0,"총매입금액")
        self.total_eval_price=self._get_comm_data(sTrCode,sRQName,0,"총평가금액")
        self.total_eval_profit_loss_price=self._get_comm_data(sTrCode,sRQName,0,"총평가손익금액")
        self.total_earning_rate=self._get_comm_data(sTrCode,sRQName,0,"총수익률(%)")
        self.estimated_deposit=self._get_comm_data(sTrCode,sRQName,0,"추정예탁자산")

        self.change_total_purchase_price = self.change_format(self.total_purchase_price)
        self.change_total_eval_price = self.change_format(self.total_eval_price)
        self.change_total_eval_profit_loss_price = self.change_format(self.total_eval_profit_loss_price)
        self.change_total_earning_rate = self.change_format2(self.total_earning_rate)
        self.change_estimated_deposit = self.change_format(self.estimated_deposit)

        self.opw00018_output['single'].append(self.change_total_purchase_price)
        self.opw00018_output['single'].append(self.change_total_eval_price)
        self.opw00018_output['single'].append(self.change_total_eval_profit_loss_price)
        self.opw00018_output['single'].append(self.change_total_earning_rate)
        self.opw00018_output['single'].append(self.change_estimated_deposit)

        # 종목별 평가 잔고 데이터 - 멀티데이터 저장
        rows=self._get_repeat_cnt(sTrCode,sRQName)

        for i in range(rows):
            code=code_pattern.search(self._get_comm_data(sTrCode,sRQName,i,"종목번호")).group(0)
            name=self._get_comm_data(sTrCode,sRQName,i,"종목명")
            quantity=self._get_comm_data(sTrCode,sRQName,i,"보유수량")
            purchase_price=self._get_comm_data(sTrCode,sRQName,i,"매입가")
            current_price=self._get_comm_data(sTrCode,sRQName,i,"현재가")
            eval_profit_loss_price=self._get_comm_data(sTrCode,sRQName,i,"평가손익")
            earning_rate=self._get_comm_data(sTrCode,sRQName,i,"수익률(%)")
            item_total_purchase=self._get_comm_data(sTrCode,sRQName,i,"매입금액")

            quantity = self.change_format(quantity)
            purchase_price = self.change_format(purchase_price)
            current_price = self.change_format(current_price)
            eval_profit_loss_price = self.change_format(eval_profit_loss_price)
            earning_rate = self.change_format2(earning_rate)
            item_total_purchase = self.change_format(item_total_purchase)

            self.opw00018_output['multi'].append(
                [name,quantity,purchase_price,current_price,eval_profit_loss_price,earning_rate,item_total_purchase,code]
            )

    # 일자별 실현 손익 요청
    def _opt10074(self,sRQName,sTrCode):
        try:
            rows = self._get_repeat_cnt(sTrCode, sRQName)
            self.total_profit = self._get_comm_data(sTrCode,sRQName, 0, "실현손익")
            self.today_profit = self._get_comm_data(sTrCode,sRQName, 0, "당일매도손익")
        except Exception as e:
            logger.critical(e)

    # 위탁종합거래내역 요청 함수
    def _opw00015(self,sRQName,sTrCode):
        rows = self._get_repeat_cnt(sTrCode, sRQName)
        acc_no = self._get_comm_data(sTrCode, sRQName, 1, "계좌번호")
        for i in range(rows):
            date = self._get_comm_data(sTrCode, sRQName, i, "거래일자")

    # 실시간체결요청 함수
    def _opt10076(self,sRQName,sTrCode):
        outputs=['주문번호','종목명','주문구분','주문가격','주문수량','체결가','체결량','미체결수량',
                 '당일매매수수료','당일매매세금','주문상태','매매구분','원주문번호','주문시간','종목코드']
        self._data={}       # 미체결 항목을 저장하는 변수

        for key in outputs:
            if key not in ['주문번호','원주문번호','주문시간','종목코드']:
                try:
                    self._data[key]=int(self._get_comm_data(sTrCode,sRQName,0,key))
                    continue
                except ValueError:
                    pass
            self._data[key]=self._get_comm_data(sTrCode,sRQName,0,key)

    # _opt10073 결과를 담는 변수를 초기화하는 함수
    def reset_opt10073_output(self):
        self.opt10073_output={'single':[],'multi':[]}

    # 일자별종목별실현손익요청 함수
    def _opt10073(self,sRQName,sTrCode):
        rows=self._get_repeat_cnt(sTrCode,sRQName)

        for i in range(rows):
            date=self._get_comm_data(sTrCode,sRQName,i,"일자")
            code=self._get_comm_data(sTrCode,sRQName,i,"종목코드")
            code_name=self._get_comm_data(sTrCode,sRQName,i,"종목명")
            amount=self._get_comm_data(sTrCode,sRQName,i,"체결량")
            today_profit=self._get_comm_data(sTrCode,sRQName,i,"당일매도손익")
            earning_rate=self._get_comm_data(sTrCode,sRQName,i,"손익율")

            code=self.change_format4(code)

            self.opt10073_output['multi'].append([date,code,code_name,amount,today_profit,earning_rate])

    # 주식분봉차트조회요청 함수
    def _opt10080(self,sRQName,sTrCode):
        data_cnt = self._get_repeat_cnt(sTrCode, sRQName)
        for i in range(data_cnt):
            date = self._get_comm_data(sTrCode, sRQName, i, "체결시간")
            open = self._get_comm_data(sTrCode, sRQName, i, "시가")
            high = self._get_comm_data(sTrCode, sRQName, i, "고가")
            low = self._get_comm_data(sTrCode, sRQName, i, "저가")
            close = self._get_comm_data(sTrCode, sRQName, i, "현재가")
            volume = self._get_comm_data(sTrCode, sRQName, i, "거래량")

            self.ohlcv['date'].append(date[:-2])
            self.ohlcv['open'].append(abs(int(open)))
            self.ohlcv['high'].append(abs(int(high)))
            self.ohlcv['low'].append(abs(int(low)))
            self.ohlcv['close'].append(abs(int(close)))
            self.ohlcv['volume'].append(int(volume))
            self.ohlcv['sum_volume'].append(int(0))

    # 데이터베이스로부터 보유하고 있는 종목의 보유량(holding amount)을 가져오는 함수
    def get_holding_amount(self,code):
        logger.debug("-* get_holding_amount function *-")
        query=f"select holding_amount from possessed_item where code='{code}'"
        result=self.engine_bot.execute(query).fetchall()
        if len(result):
            return result[0][0]
        else:
            return False

    # open_api로부터 받아온 데이터의 형식을 변형하는 함수
    # 데이터 값 앞의 의미없는 0을 제거
    def change_format(self,data):
        try:
            strip_data=data.lstrip('0')
            # 유효한 값이 존재하지 않을 경우 0으로 대체
            if strip_data=="":
                strip_data='0'
            return int(strip_data)
        except Exception as e:
            logger.critical(e)

    # 수익률을 소수 형태로 변환하는 함수
    def change_format2(self,data):
        try:
            strip_data=data.lstrip('-0')
            # 유효한 값이 없을 경우 0으로 대체
            if strip_data=="":
                strip_data='0'
            else:
                strip_data=str(float(strip_data)/self.mod_gubun)
                # 수익률< 1 일 경우
                if strip_data.startswith('.'):
                    strip_data='0'+strip_data
                # 수익률 < 0 일 경우
                if data.startswith('-'):
                    strip_data='-'+strip_data
            return strip_data
        except Exception as e:
            logger.critical(e)

    # 특수문자(%), 앞뒤 공백 제거 함수
    def change_format3(self,data):
        try:
            strip_data=data.stript('%')
            strip_data=strip_data.strip()
            return strip_data
        except Exception as e:
            logger.critical(e)

    # 코드 앞의 문자를 제거하는 함수수
    def change_format4(sel,data):
        try:
            strip_data=data.lstrip('A')
            return strip_data
        except Exception as e:
            logger.critical(e)

    # open api 조회 요청 수를 체크하는 함수
    # 최대 조회 요청 가능 횟수를 넘어서면, 프로그램을 종료
    def exit_check(self):
        rq_delay=datetime.timedelta(seconds=0.6)
        time_diff=datetime.datetime.now()-self.call_time
        if rq_delay>time_diff:
            time.sleep((rq_delay-time_diff).total_seconds())

        self.rq_count+=1

        logger.debug(self.rq_count)
        if self.rq_count==self.cf.max_api_call:
            sys.exit(1)

if __name__=="__main__":
    app=QApplication(sys.argv)
    a=open_api()