2020-2-capstone-design2 / 2015104491

Go to a project
Toggle navigation Toggle navigation pinning
이하영
16d854db 1 parent 6cebd4be

tr관련 함수 추가

Inline Side-by-side
Showing 13 changed files with 524 additions and 239 deletions
import logging.handlers
import sys
# formmater 생성
formatter = logging.Formatter('[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s > %(message)s')
# logger 인스턴스를 생성 및 로그 레벨 설정
logger = logging.getLogger("crumbs")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
\ No newline at end of file
import datetime
from sqlalchemy import *
import pymysql
from pandas import DataFrame
import config
class Simulator_Api:
def __init__(self,simul_num,op,db_name):
self.simul_num=int(simul_num)
if op=="real":
self.op='real'
self.simul_reset=False
self.db_name=db_name
self.set_variable()
def set_date(self):
self.today=datetime.datetime.today().strftime("%Y%m%d")
def set_variable(self):
self.set_date()
self.set_database()
# 매수/매도 알고리즘 선택 -> 차후 알고리즘 별로 구현 및 재설정
self.buy_algorithm=1
self.sell_algorithm=1
# 특정 데이터베이스 내에 특정 테이블이 존재하는지 확인하는 함수
def is_table_exist(self,db_name,table_name):
query="select 1 from information_schema.tables where table_schema='%s' and table_name='%s'"
result=self.engine_simul.execute(query%(db_name,table_name)).fetchall()
if len(result)==1:
return True
else:
return False
# 데이터베이스 연결 설정
def set_database(self):
if self.op=="real":
self.engine_simul=create_engine("mysql+pymysql://"+config.db_id+":"+config.db_pw+"@"+config.db_ip+
":"+config.db_port+"/"+str(self.db_name),encoding='utf-8')
else:
self.db_name='simulator'+str(self.simul_num)
self.engine_simul=create_engine("mysql+pymysql://"+config.db_id+":"+config.db_pw+"@"+config.db_ip+
":"+config.db_port+"/"+str(self.db_name),encoding='utf-8')
self.engine_daily = create_engine("mysql+pymysql://" + config.db_id + ":" + config.db_pw + "@" + config.db_ip +
":" + config.db_port + "/daily_info" , encoding='utf-8')
self.engine_stock = create_engine("mysql+pymysql://" + config.db_id + ":" + config.db_pw + "@" + config.db_ip +
":" + config.db_port + "/stock_info", encoding='utf-8')
self.engine_minute = create_engine("mysql+pymysql://" + config.db_id + ":" + config.db_pw + "@" + config.db_ip +
":" + config.db_port + "/minute_info", encoding='utf-8')
self.conn=pymysql.connect(
host=config.db_ip,
port=int(config.db_port),
user=config.db_id,
password=config.db_pw,
charset='utf8'
)
# 날짜별 주식 데이터를 저장해 놓은 데이터베이스에서 가장 최근 날짜를 가져오는 함수
def get_latest_date(self):
query="select table_name from information_schema.tables where table_schema='daily_info' and " \
"table_name like '%s' order by table_name desc limit 1"
result=self.engine_daily.execute(query%("20%%")).fetchall()
if len(result)==0:
return False
else:
return result[0][0]
# transaction_history 테이블의 Dataframe 생성
def df_transaction_history(self):
df_temp={'id':[]}
self.df_th=DataFrame(df_temp,
columns=['id','order_num','code','code_name','rate','purchase_rate',
'purchase_price','present_price','valuation_price','valuation_profit',
'holding_amount','buy_date','total_purchase_price','contract_check','per_invest',
'sell_date','sell_price','sell_rate'
])
# daily_info 데이터베이스에서 특정 날짜에서 특정 코드에 해당하는 정보만 가져오는 함수수
def get_daily_info_by_code(self,code,date):
query="select * from {} where code='{}' group by code"
daily_info=self.engine_daily.execute(query.format(date,code)).fetchall()
df_daily_info=DataFrame(daily_info,
columns=['index','index2','date','check_item','code',
'code_name','dff_rate',
'close','open','high','low','volume',
'avg5','avg10','avg20','avg60','avg120',
'prev_avg5','prev_avg10','prev_avg20','prev_avg60','prev_avg120',
'avg5_diff_rate','avg10_diff_rate','avg20_diff_rate','avg60_diff_rate',
'avg120_diff_rate',
'vol5','vol10','vol20','vol60','vol120'])
return df_daily_info
\ No newline at end of file
No preview for this file type
from sqlalchemy import *
from open_api import *
from daily_info import *
from stock_info import *
import config
class CollectorApi():
def __init__(self):
self.open_api=OpenApi()
self.engine_bot=self.open_api.engine_bot
def set_variable(self):
self.open_api.sort="collector"
self.stock_info=StockInfo(config.real_bot,config.real_stockInfo,config.real_dailyInofo)
self.daily_info=DailyInfo()
def update_code(self):
print("update code")
query = "select code_update,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"
result=self.engine_bot.execute(query).fetchall()
print(result)
if result[0][0]!=self.open_api.today():
self.open_api.check_balance()
self.get_code_list()
def set_db_minute_info(self):
print("Make Minute Info Database")
query="select code,code_name from stock_all"
target=self.open_api.engine_dInfo.execute(query).fetchall()
print(target)
app = QApplication(sys.argv)
c=CollectorApi()
c.update_code()
\ No newline at end of file
......
......@@ -9,5 +9,16 @@ test_account_no="8147766711"
# 시뮬레이션을 돌리기 시작할 날짜
start_buying='20190101'
simul_num1=1
simul_name1="AutoBot"+str(simul_num1)+"_Test"
test_num=1
test_bot_name="AutoBot"+str(test_num)+"_Test"
# 실전투자 정보
real_account_no=""
real_num=1
# 데이터베이스 이름
real_bot_name="AutoBot"+str(real_num)
real_stockInfo_name="stock_info"
real_dailyInfo_name="daily_info"
\ No newline at end of file
......
from PyQt5.QtWidgets import *
from PyQt5.QAxContainer import *
from PyQt5.QtCore import *
from PyQt5.QtTest import *
from pandas import DataFrame
import sys
from PyQt5.QAxContainer import *
from PyQt5.QtWidgets import *
import pymysql
import datetime
from sqlalchemy import *
from collections import defaultdict
from pandas import DataFrame
from Logger import *
import config
import error_code
from Simulator_Api import *
TR_REQ_TIME_INTERVAL = 3600
pymysql.install_as_MySQLdb()
class OpenApi(QAxWidget):
class Open_Api(QAxWidget):
def __init__(self):
super().__init__()
# event_loop list
self.tr_event_loop=QEventLoop()
self.login_event_loop=QEventLoop()
self.tr_event_loop=QEventLoop()
# variable list
self.account_no=None # 계좌번호
self.ohlcv = None # 거래정보(시가,종가,고가,저가,거래량)
self.remained_data=None # 다음페이지 존재여부
self.simul_num=None # 모의투자 번호
self.db_name=None # 거래데이터를 담고 있는 AutoBot 데이터베이스
# engine list
self.engine_bot=None # AutoBot데이터베이스에 접속하는 engine
# screen number list
self.screen_data_req="0101" # 거래 데이터
self.create_instance()
self._signal_slots()
self.comm_connect() # 로그인
self.get_account_info() # 계좌정보 가져오기
self.variable_setting() # 데이터베이스 설정
# 데이터베이스 설정
def variable_setting(self):
print("============variable setting function===============")
# 모의투자인 경우
if self.account_no == config.test_account_no:
self.simul_num = config.simul_num1
self.db_name_setting(config.simul_name1)
# AutoBot Database 생성
def create_database(self,cursor):
print("create database")
query="create database {}"
cursor.execute(query.format(self.db_name))
# open_api 호출 횟수를 저장f
self.rq_count=0
self.set_date()
self.tr_loop_count=0
self.call_time=datetime.datetime.now()
# AutoBot Database가 존재하는지 여부를 확인
def is_BotTable_exist(self,cursor):
query="select 1 from information_schema.schemata where schema_name='{}'"
print(query.format(self.db_name))
if (cursor.execute(query.format(self.db_name))):
print("%s 데이터베이스가 존재합니다.",self.db_name)
return True
# open_api 연동
self._create_instance()
self._set_signal_slots()
self.comm_connect()
# 계좌정보 출력
self.get_account_info()
# 변수 설정
self.set_variable()
self.simul_api=Simulator_Api(self.simul_num,"real",self.db_name)
logger.debug("알고리즘 번호 : %s",self.simul_api.simul_num)
logger.debug("매수 알고리즘 번호 : %s",self.simul_api.buy_algorithm)
logger.debug("매도 알고리즘 번호 : %s",self.simul_api.sell_algorithm)
if not self.simul_api.is_table_exist(self.db_name,"setting_data"):
self.create_setting_data()
self.set_simul_variable()
self.ohlcv=defaultdict(list)
# 날짜 설정
def set_date(self):
self.today=datetime.datetime.today().strftime("%Y%m%d")
self.today_time=datetime.datetime.today().strftime("%Y%m%d%H%M")
# 키움 open_api 를 사용하기 위한 ocx controller 생성
def _create_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:
return False
logger.debug("connection failed...")
self.login_event_loop.exit()
except Exception as e:
logger.critical(e)
# 데이터베이스 확인 및 생성
def db_name_setting(self,db_name):
self.db_name=db_name
print("db_name : %s"%self.db_name)
conn = pymysql.connect(
host=config.db_ip,
port=int(config.db_port),
user=config.db_id,
password=config.db_pw,
charset='utf8'
)
cursor=conn.cursor()
if not self.is_BotTable_exist(cursor):
self.create_database(cursor)
self.engine_bot=create_engine(
"mysql+pymysql://" + config.db_id + ":" + config.db_pw + "@" + config.db_ip + ":" + config.db_port + "/" +
db_name, encoding='utf-8')
self.db_setting(cursor)
# AutoBot 이외에 필요한 데이터베이스를 생성
def db_setting(self,cursor):
# 생성해야 할 데이터베이스 리스트
to_create=['stock_info','daily_info','minute_info']
query="select schema_name from information_schema.schemata"
cursor.execute(query)
result=cursor.fetchall()
create_db="CREATE DATABASE {}"
# 생성되어 있는 데이터베이스 리스트
created=list()
for item in result:
created.append(item[0])
# 생성하야 할 데이터베이스가 존재하지 않는 경우 새로 생성
for db in to_create:
if db not in created:
print(db,"데이터베이스가 존재하지 않습니다. 데이터베이스를 새로 생성합니다.")
create_query=create_db.format(db)
cursor.execute(create_query)
print(db,"데이터베이스 생성 완료!")
# 주식일봉차트조회요청
def _opt10081(self,sRQName,sTrCode):
QTest.qWait(TR_REQ_TIME_INTERVAL)
cnt=self._get_repeat_cnt(sTrCode,sRQName)
for i in range(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['volumn'].append(int(volume))
# 수동 로그인설정인 경우 로그인창을 출력해서 로그인을 시도
# 자동로그인 설정인 경우 로그인창 출력없이 로그인을 시도
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 "" : 다음페이지 없음
# 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
if sRQName=="opt10081":
print("==============주식일봉차트조회요청================")
# Request 요청에 따른 함수 처리
if sRQName == "opt10081_req" and self.purpose == "trader":
logger.debug("주식일봉차트조회요청")
self._opt10081(sRQName,sTrCode)
elif sRQName=="opw0001_req":
return
elif sRQName=="opw00018_req":
return
elif sRQName=="opt10074_req":
return
elif sRQName=="opw00015_req":
return
elif sRQName=="opt10076_req":
return
elif sRQName=="opt10073_req":
return
elif sRQName == "opt10081_req" and self.purpose == "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._opt10084(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
# 특정 종목의 일자별 거래 데이터 조회 함수
# param : code - 종목코드
# start - 기준일자
# return : df - 특정종목의 일자별 거래 데이터 목록
def get_total_data(self,code,start):
self.ohlcv = {'date': [], 'open': [], 'high': [], 'low': [], 'close': [], 'volume': []}
self._set_input_value("종목코드",code)
self._set_input_value("기준일자",start)
self._set_input_value("수정주가구분",1)
self._comm_rq_data("opt10081_req","opt10081",0,self.screen_data_req)
while self.remained_data:
self._set_input_value("종목코드",code)
self._set_input_value("기준일자",start)
self._set_input_value("수정주가구분",1)
self._comm_rq_data("opt10081_req","opt10081",2,self.screen_data_req)
# 데이터가 없거나, date=''일 경우 empty list를 반환
if len(self.ohlcv)==0:
return []
if self.ohlcv['date']=='':
return []
# 데이터를 DataFrame형태로 저장 및 반환
df=DataFrame(self.ohlcv,columns=['open','high','low','close','volume'],index=self.ohlcv['date'])
return df
# 특정 종목의 특정 날짜의 시가,종가,고가,저가,거래량 중 특정한 데이터를 반환하는 함수
# param : code - 종목코드
# : date - 조회날짜
# : option - open(시가)/close(종가)/high(고가)/low(저가)/volume(거래량)
# return : 조회한 데이터에 해당하는 값
# 값이 없거나, option이 오류일 경우 return False
def get_oneday_option_data(self,code,date,option):
self.ohlcv = {'date': [], 'open': [], 'high': [], 'low': [], 'close': [], 'volume': []}
self._set_input_value("종목코드",code)
self._set_input_value("기준일자",date)
self._set_input_value("수정주가구분",1)
self._comm_rq_data("opt10081_req","opt10081",0,self.screen_data_req)
if self.ohlcv['date']=="":
return False
df = DataFrame(self.ohlcv, columns=['open', 'high', 'low', 'close', 'volume'], index=self.ohlcv['date'])
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
# 서버통신 후 수신한 메시지를 알려주는 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):
# 현재 체결 진행 중인 코드
print("주분번호 : ",self.get_chejan_data(9023))
print("종목명 : ",self.get_chejan_data(302))
print("주문수량 : ",self.get_chejan_data(900))
print("주문가격 : ",self.get_chejan_data(901))
# OnReceiveChejan()이벤트가 호출될때 체결정보나 잔고정보를 얻어오는 함수
# param : nFid - 실시간 타입에 포함된 FID
def get_chejan_data(self,nFid):
try:
ret=self.dynamicCall("GetChejanData(int)",nFid)
return ret
except Exception as e:
logger.critical(e)
# 사용자의 계좌정보 저장 및 출력
def get_account_info(self):
account=self.get_login_info("ACCNO")
self.account_no=account.split(";")[0]
print("======== 계좌번호 : ",self.account_no,"========")
account_no=self.get_login_info("ACCNO")
self.account_no=account_no.split(";")[0]
logger.debug(self.account_no)
# 원하는 사용자 정보 반환
# param : tag - ACCNO - 보유계좌리스트
......@@ -236,50 +196,7 @@ class OpenApi(QAxWidget):
ret=self.dynamicCall("GetLoginInfo(QString)",tag)
return ret
except Exception as e:
print(e)
sys.exit()
# 키움 api를 사용하기 위한 ocx controller 저장
def create_instance(self):
try:
self.setControl("KHOPENAPI.KHOpenAPICtrl.1")
except Exception as e:
print(e)
sys.exit()
# event처리를 위한 slot
def _signal_slots(self):
try:
self.OnEventConnect.connect(self._login_slot)
self.OnReceiveTrData.connect(self._receive_tr_data)
except Exception as e:
print(e)
sys.exit()
# 수동 로그인설정인 경우 로그인창을 출력해서 로그인을 시도
# 자동로그인 설정인 경우 로그인창 출력없이 로그인을 시도
def comm_connect(self):
try:
self.dynamicCall("CommConnect()")
self.login_event_loop.exec_()
except Exception as e:
print(e)
sys.exit()
# 로그인 이벤트 처리 slot
# param : code - 로그인 성공 시 0
# 실패 시 에러코드 출력
def _login_slot(self,code):
try:
result=error_code.errors(code)
if code==0:
print("Connected",result[1])
else:
print("Failed to connect",result[1])
self.login_event_loop.exit()
except Exception as e:
print(e)
sys.exit()
logger.critical(e)
# 조회요청시 TR의 Input값을 지정하는 함수
# param : sId - TR에 명시된 Input이름
......@@ -320,6 +237,190 @@ class OpenApi(QAxWidget):
print(e)
sys.exit()
if __name__ == "__main__":
app = QApplication(sys.argv)
api=OpenApi()
\ No newline at end of file
# 변수 설정
# 실전투자인지 모의투자인지 여부를 확인하고 그에 해당하는 데이터베이스를 생성하는 함수
def set_variable(self):
self.config=config
if self.account_no==self.config.real_account_no:
logger.debug("실전투자")
self.simul_num=self.config.real_num
self.set_database(self.config.real_bot_name)
elif self.account_no==self.config.test_account_no:
logger.debug("모의투자")
self.simul_num=self.config.test_num
self.set_database(self.config.test_bot_name)
else:
logger.debug("Invalid Account Number. Check the Config.py")
exit(1)
# 데이터베이스 생성 및 엔진 설정
def set_database(self,db_name):
self.db_name=db_name
conn=pymysql.connect(
host=config.db_ip,
port=int(config.db_port),
user=config.db_id,
password=config.db_pw,
charset='utf8'
)
cursor=conn.cursor()
if not self.is_database_exist(cursor):
self.create_database(cursor)
self.engine_bot=create_engine("mysql+pymysql://"+self.config.db_id+":"+self.config.db_pw+"@"+
self.config.db_ip + ":" + self.config.db_port+"/"+db_name,encoding='utf-8')
self.create_info_database(cursor)
conn.commit()
cursor.close()
conn.close()
self.engine_daily=create_engine("mysql+pymysql://"+self.config.db_id+":"+self.config.db_pw+"@"+
self.config.db_ip + ":" + self.config.db_port+"/daily_info",encoding='utf-8')
self.engine_stock=create_engine("mysql+pymysql://"+self.config.db_id+":"+self.config.db_pw+"@"+
self.config.db_ip + ":" + self.config.db_port+"/stock_info",encoding='utf-8')
self.engine_minute=create_engine("mysql+pymysql://"+self.config.db_id+":"+self.config.db_pw+"@"+
self.config.db_ip + ":" + self.config.db_port+"/minute_info",encoding='utf-8')
# Bot Database가 존재하는지 확인하는 함수
def is_database_exist(self,cursor):
query="select 1 from information_schema.schemata where schema_name='{}'"
result=cursor.execute(query.format(self.db_name))
if result:
return True
else:
return False
# Bot Database를 생성하는 함수
def create_database(self,cursor):
query="create database {}"
cursor.execute(query.format(self.db_name))
# information 데이터베이스가 존재하는지 확인
# 존재하지 않는다면 새로 생성
def create_info_database(self,cursor):
info_list=['daily_info','stock_info','minute_info']
query="select schema_name from information_schema.schemata"
cursor.execute(query)
result=cursor.fetchall()
print(result)
exist_list=[item[0].lower() for item in result]
create_query="create database {}"
has_created=False
for db in info_list:
if db not in exist_list:
has_created=True
logger.debug(db,"Database not exist. Create the Database.")
cursor.execute(create_query.format(db))
logger.debug(db,"Creation Completed!")
if has_created and self.engine_bot.has_table('setting_data'):
print("exist")
self.engine_bot.execute("update setting_data set code_update='0")
def create_setting_data(self):
df_data={"limit_money":[],"per_invest":[],"max_per_invest":[],"min_per_invest":[],"set_per_invest":[],
"code_update":[],"today_finish":[],"balance_to_db":[],"posses_stocks":[],"today_profit":[],
"contract_check":[],"db_to_daily_info":[],"today_buy_list":[],"stock_info":[],"daily_info":[]}
df_setting_data=DataFrame(df_data,
columns=['limit_money','per_invest','max_per_invest','min_per_invest','set_per_invest',
'code_update','today_finish','balance_to_db','posses_stocks','today_profit',
'contract_check','db_to_daily_info','today_buy_list','stock_info','daily_info'])
df_setting_data.loc[0,'limit_money']=int(0)
df_setting_data.loc[0,'per_invest']=int(0)
df_setting_data.loc[0,'max_per_invest']=int(0)
df_setting_data.loc[0,'min_per_invest']=int(0)
df_setting_data.loc[0,'set_per_invest']=str(0)
df_setting_data.loc[0,'code_update']=str(0)
df_setting_data.loc[0,'today_finish']=str(0)
df_setting_data.loc[0,'balance_to_db']=str(0)
df_setting_data.loc[0,'posses_stocks']=str(0)
df_setting_data.loc[0,'today_profit']=float(0)
df_setting_data.loc[0,'contract_check']=str(0)
df_setting_data.loc[0,'db_to_daily_info']=str(0)
df_setting_data.loc[0,'today_buy_list']=str(0)
df_setting_data.loc[0,'stock_info']=str(0)
df_setting_data.loc[0,'daily_info']=str(0)
df_setting_data.to_sql("setting_data",self.engine_bot,if_exists="replace")
def set_simul_variable(self):
self.latest_date=self.simul_api.get_latest_date()
if not self.simul_api.is_table_exist(self.db_name,"transaction_history"):
logger.debug("create transaction_history table")
self.per_invest=0
self.create_transaction_history(0,0,0,0,0)
self.delete_item_by_code(0)
# transaction_history 테이블 생성 및 column 설정
def create_transaction_history(self,order_num,code,contract_check,purchase_price,rate):
logger.debug("creating transaction_history table")
self.set_date()
self.simul_api.df_transaction_history()
self.simul_api.df_th.loc[0,'order_num']=order_num
self.simul_api.df_th.loc[0,'code']=str(code)
self.simul_api.df_th.loc[0,'reate']=float(rate)
self.simul_api.df_th.loc[0,'buy_date']=self.today_time
self.simul_api.df_th.loc[0,'contract_check']=contract_check
self.simul_api.df_th.loc[0,'per_invest']=self.per_invest
self.simul_api.df_th.loc[0,'purchase_price']=purchase_price
self.simul_api.df_th=self.simul_api.df_th.fillna(0)
self.simul_api.df_th.to_sql('transaction_history',self.engine_bot,if_exists='append')
def delete_item_by_code(self,code):
query="delete from transaction_history where code='%s'"
self.engine_bot.execute(query%code)
# setting_data에 per_invest항목이 설정되어 있는지 확인하는 함수
def check_per_invest(self):
query="select per_invest, set_per_invest from setting_data"
result=self.engine_bot.execute(query).fetchall()
if result[0][1]==self.today:
self.per_invest=result[0][0]
return True
else:
return False
def set_per_invest(self):
self.get_deposit()
# 예수금 조회 및 저장
def get_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 _opw00001(self,sRQName,sTrCode):
self.deposit=self._get_comm_data(sTrCode,sRQName,0,"d+2출금가능금액")
self.deposit=int(self.deposit)
def get_balance(self):
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")
def _opw00018(self,sRQName,sTrCode):
self.total_purchase=self._get_comm_data(sTrCode,sRQName,0,"총매입금액")
self.total_evaluated_price=self._get_comm_data(sTrCode,sRQName,0,"총평가금액")
self.total_valuation=self._get_comm_data(sTrCode,sRQName,0,"총평가손익금액")
self.earning_rate=self._get_comm_data(sTrCode,sRQName,0,"총수익률(%)")
self.estimated_deposit=self._get_comm_data(sTrCode,sRQName,0,"추정예탁자산")
self.total_purchase=int(self.total_purchase)
self.total_evaluated_price=int(self.total_evaluated_price)
self.total_valuation=int(self.total_valuation)
self.earning_rate=float(self.earning_rate)
self.estimated_deposit=int(self.estimated_deposit)
if __name__=="__main__":
app=QApplication(sys.argv)
a=Open_Api()
a.get_balance()
\ No newline at end of file
......
from sqlalchemy import *
from PyQt5.QtCore import *
import datetime
import config
class StockInfo():
def __init__(self):
def __init__(self,db_name,stock_info_name,daily_info_name):
if db_name!=0:
self.db_name=db_name
self.stockInfo_name=stock_info_name
self.dailyInfo_name=daily_info_name
self.engine=create_engine(
"mysql+pymysql://" + config.db_id + ":" + config.db_pw + "@" + config.db_ip + ":" + config.db_port +
"/stock_info", encoding='utf-8')
self.conn=self.engine.connect()
self.set_variable()
# 변수 설정
def set_variable(self):
self.mkt_start_time=QTime(9,0,0)
self.mkt_end_time=QTime(15,31,0)
self.today=datetime.datetime.today().strftime("%Y%m%d")
# 현재 시간이 주식장이 열린 시간인지 확인하는 함수
def time_check(self):
self.current_time=QTime.currentTime()
if (self.current_time>self.mkt_start_time and self.current_time<self.mkt_end_time):
return True
else:
return False
\ No newline at end of file
......