def __init__(self, inForm):
threading.Thread.__init__(self)
self.daemon = True
# 테스트 시세 수신제어
global isTestQttnRunning
# 진행시세 index
global qIndex
qIndex = 0
# 데이터 준비 확인
global existTestQttn
existTestQttn = False
# 시세 종목리스트
global QttnStkList
# 테스트시세
global SavedQttnList
global SavedQttnCnt
SavedQttnList = None
SavedQttnCnt = 0
# 메인폼
self.MainForm = inForm
# DB 핸들러
self.DBH = DB_handler()
# 시세종목리스트 초기화
QttnStkList = self.MainForm.GetProcStkList()
QttnStkList.insert(0, CodeDef.INDEX_STK_CD)
# 테스트시세준비
SavedQttnList = self.DBH.querySavedTestQttn()
SavedQttnCnt = len(SavedQttnList.index)
print("테스트 시세 조회완료")
return None
def login():
error = ''
try:
if request.method == "POST":
data = request.get_json()
print(data)
if not request.is_json:
print("json was not found")
return "<h2>Problem with the Json</h2>"
DB_handler.user_login(data)
print("finish db update")
return json.dumps(data)
except Exception as e:
print("exception")
return render_template('index.html', error=error)
def retrieve_history():
first_name = ent_first_name.get()
last_name = ent_last_name.get()
loinc_num = ent_loinc_num.get()
valid_start_time_from = parse_date_time_input(ent_start_date,
ent_start_hour,
ent_start_minute)
valid_start_time_to = parse_date_time_input(ent_end_date, ent_end_hour,
ent_end_minute)
transaction_time = parse_date_time_input(ent_view_date, ent_view_hour,
ent_view_minute)
print("hello")
answer = DB_handler.retrieve(
loinc_num=loinc_num,
first_name=first_name,
last_name=last_name,
valid_start_time=valid_start_time_from,
valid_start_time_end=valid_start_time_to,
transaction_time=transaction_time,
)
create_popup(answer=answer)
def delete():
error = ''
try:
if request.method == "POST":
data = request.get_json()
print(data)
if not request.is_json:
print("json was not found")
return "<h2>Problem with the Json</h2>"
DB_handler.delete_user(data)
print("account was deleted")
return json.dumps(data)
except Exception as e:
print("exception")
return render_template('Delete_User.html', error=error)
def __init__(self, isUnite="None"):
# 통합실행일경우 3초 딜레이
if (isUnite == "TRUE"):
time.sleep(5)
super().__init__()
# 폼 설정
self.setupUi(self)
# 전역변수
global isRcv # 수신중여부
isRcv = False
# 객체변수 설정
self.gAPIH = None # API 핸들러
self.gSckt = None # 송신소켓 핸들러
self.gDBH = None # DB 핸들러
# 버튼이벤트 핸들러 설정
self.btnRcvIdx.clicked.connect(self.ClickRcvIdx) # 지수수신시작 버튼
self.btnStopRcvIdx.clicked.connect(self.ClickStopRcvIdx) # 지수수신종료 버튼
self.btnInitQttn.clicked.connect(self.ClickInitQttn) # 지수수시세 초기화 버튼
# 상태표시
self.edtStat.setText("시작전")
# API 초기화
try:
self.gAPIH = TradarAPI_handler()
#self.gAPIH = GlobalAPI_handler()
self.gAPIH.initAPI(True, self) # 전송모드 초기화
print("TRADAR end ")
except Exception as e:
print(e)
# 전송소켓 초기화
self.gSckt = SndSckt_handler()
# DB 핸들러 초기화
self.gDBH = DB_handler()
# 지수최근 동기화일자 표시
self.SetLastDtMn()
return None
def index():
error = ''
try:
if request.method == "POST":
data = request.get_json()
print(data)
if not request.is_json:
print("json was not found")
return "<h2>Problem with the Json</h2>"
print(DB_handler.user_login(data))
if DB_handler.user_login(data):
print("successfuly logged in")
return json.dumps(data)
except Exception as e:
print("exception")
return render_template('main.html', error=error)
class InStkForm_handler(QDialog, InStkFormClass):
def __init__(self):
super().__init__()
# 객체변수 설정
self.gStkDbh = DB_handler() # DB 핸들러
# 폼 설정
self.setupUi(self)
self.btnSave.clicked.connect(self.ClickSave)
self.btnClse.clicked.connect(self.ClickClse)
self.cmbMktTpCd.addItem("0.국내(주식,선물옵션)")
self.cmbMktTpCd.addItem("1.해외 주식")
self.cmbMktTpCd.addItem("2.해외 선물옵션")
self.cmbMktTpCd.addItem("3.국내 주식")
self.cmbMktTpCd.addItem("4.국내 선물")
self.cmbMktTpCd.addItem("5.국내 옵션")
self.cmbMktTpCd.addItem("6.해외 선물")
self.cmbMktTpCd.addItem("7.해외 옵션")
self.dedtStrDt.setCalendarPopup(True)
self.dedtEndDt.setCalendarPopup(True)
self.dedtStrDt.setDate(datetime.datetime.today())
self.dedtEndDt.setDate(QtCore.QDate(3000, 1, 1))
return None
def __del__(self):
del self.gStkDbh
return None
def ClickSave(self):
try:
self.gStkDbh.insertProcStk(self.cmbMktTpCd.currentText()[:1],
self.edtStkCd.text(),
self.dedtStrDt.text().replace("-", ""),
self.dedtEndDt.text().replace("-", ""))
except Exception as e:
print(e)
self.close()
return None
def ClickClse(self):
self.close()
return None
def initAPI(self, inMode, inForm):
UserID = CodeDef.API_USER_ID
PassWord = CodeDef.API_USER_PW
CertPW = CodeDef.API_CERT_PW
global gTRADR_SYS_MSG_CD # 티레이더 시스템메시지 코드
global gTradrSess_flag # 티레이더 요청대기 제어
global gTradrAPI # 티레이더 API 핸들러
global gTradrInitDict # 티레이더 분봉초기화 딕셔너리 {("MN_INIT",TR번호,종목코드) : (시작일,시작시분,종료일,종료시분,요청ID)}
global gTradrTrReqDict # 티레이더 요청TR-결과코드 딕셔너리 { 결과코드 : (TRID,종목코드) }
global gTradrRealReqDict # 티레이더 실시간 요청정보 딕셔너리 { 결과코드 : (TRID,종목코드) or 종목보드 : (TRID, 결과코드)}
global gTradrApiDbh # 티레이더 DB 핸들러
global gIsTrmsMode # 전송모드 접속여부
global gMainForm # 메인폼 핸들러
gTRADR_SYS_MSG_CD = 0
gTradrSess_flag = False
gTradrAPI = None
gTradrInitDict = {}
gTradrTrReqDict = {}
gTradrRealReqDict = {}
gTradrApiDbh = None
gIsTrmsMode = inMode
gMainForm = inForm
# API 초기화
gTradrApiDbh = DB_handler()
gTradrAPI = win32com.client.DispatchWithEvents(
"YuantaAPICOM.YuantaAPI", TradarAPI_handler)
ret = gTradrAPI.YOA_Initial(CodeDef.SERVER_REAL_TRADAR,
r"C:\YuantaAPI")
ret = gTradrAPI.YOA_Login(UserID, PassWord, CertPW)
# 혹시 남아있는 실시간 TR이 있다면 중지
gTradrAPI.YOA_UnRegistAuto("11")
gTradrSess_flag = True
while gTradrSess_flag:
pythoncom.PumpWaitingMessages()
if (gTRADR_SYS_MSG_CD == CodeDef.NOTIFY_SYSTEM_NEED_TO_RESTART
): # 모듈변경에 때른 재시작 필요
ret = gTradrAPI.YOA_UnInitial()
os.chdir(r"C:\YuantaAPI")
cwd = os.getcwd()
os.system("YOASync.exe")
time.sleep(2)
os.chdir(cwd)
ret = gTradrAPI.YOA_Initial(CodeDef.SERVER_REAL_TRADAR,
r"C:\YuantaAPI")
ret = gTradrAPI.YOA_Login(UserID, PassWord, CertPW)
return None
def __init__(self):
super().__init__()
# 객체변수 설정
self.gStkDbh = DB_handler() # DB 핸들러
# 폼 설정
self.setupUi(self)
self.btnSave.clicked.connect(self.ClickSave)
self.btnClse.clicked.connect(self.ClickClse)
self.cmbMktTpCd.addItem("0.국내(주식,선물옵션)")
self.cmbMktTpCd.addItem("1.해외 주식")
self.cmbMktTpCd.addItem("2.해외 선물옵션")
self.cmbMktTpCd.addItem("3.국내 주식")
self.cmbMktTpCd.addItem("4.국내 선물")
self.cmbMktTpCd.addItem("5.국내 옵션")
self.cmbMktTpCd.addItem("6.해외 선물")
self.cmbMktTpCd.addItem("7.해외 옵션")
self.dedtStrDt.setCalendarPopup(True)
self.dedtEndDt.setCalendarPopup(True)
self.dedtStrDt.setDate(datetime.datetime.today())
self.dedtEndDt.setDate(QtCore.QDate(3000, 1, 1))
return None
def initAPI(self,inMode, inForm):
UserID = CodeDef.API_USER_ID
PassWord = CodeDef.API_USER_PW
CertPW = CodeDef.API_CERT_PW
# 데이터 수신
global gGLBL_SYS_MSG_CD # 티레이더글로벌 시스템메시지 코드
global gGlblSess_flag # 티레이더글로벌 요청대기 제어
global gGlblAPI # 티레이더글로벌 API 핸들러
global gGlblInitDict # 티레이더글로벌 분봉초기화 딕셔너리 {("MN_INIT",TR번호,종목코드) : (시작일,시작시분,종료일,종료시분)}
global gGlblTrReqDict # 티레이더글로벌 조회요청정보 딕셔너리 { 결과코드 : (TRID,종목코드) }
global gGlblRealReqDict # 티레이더글로벌 실시간 요청정보 딕셔너리 { 결과코드 : (TRID,종목코드) or 종목보드 : (TRID, 결과코드)}
global gGlblApiDbh # 티레이더글로벌 DB 핸들러
global gIsTrmsMode # 전송모드 접속여부
global gMainForm # 메인폼 핸들러
gGLBL_SYS_MSG_CD = 0
gGlblSess_flag = False
gGlblAPI = None
gGlblInitDict = {}
gGlblTrReqDict = {}
gGlblRealReqDict = {}
gGlblApiDbh = None
gIsTrmsMode = inMode
gMainForm = inForm
# 접속에따른 초기화
gGlblAPI = win32com.client.DispatchWithEvents("YuantaAPICOM.YuantaAPI", GlobalAPI_handler)
gGlblApiDbh = DB_handler()
ret = gGlblAPI.YOA_Initial(CodeDef.SERVER_REAL_GLOBAL, r"C:\YuantaAPI")
ret = gGlblAPI.YOA_Login(UserID, PassWord, CertPW)
# 혹시 남아있는 실시간 TR이 있다면 중지
gGlblAPI.YOA_UnRegistAuto("61")
gGlblSess_flag = True
while gGlblSess_flag:
pythoncom.PumpWaitingMessages()
if (gGLBL_SYS_MSG_CD == CodeDef.NOTIFY_SYSTEM_NEED_TO_RESTART): # 모듈변경에 때른 재시작 필요
ret = gGlblAPI.YOA_UnInitial()
os.chdir(r"C:\YuantaAPI")
cwd = os.getcwd()
os.system("YOASync.exe")
time.sleep(2)
os.chdir(cwd)
ret = gGlblAPI.YOA_Initial(CodeDef.SERVER_REAL_GLOBAL, r"C:\YuantaAPI")
ret = gGlblAPI.YOA_Login(UserID, PassWord, CertPW)
return None
def __init__(self):
# variable, if the Controller is running
self.isRunning = False
# if the humifier is running (-> relay is closed)
self.humi_is_Running = False
self.database_handler = DB_handler.Database_handler()
# init meteo sensor and do test-ready
self.meteoSensorHandler = meteo_Handler.meteo_Handler()
self.meteoSensorHandler.setDevice("0x77")
temperature, pressure, humidity = self.meteoSensorHandler.readBME280All(
)
def register():
error = ''
try:
if request.method == "POST":
data = request.get_json()
print(data)
if not request.is_json:
print("json was not found")
return "<h2>Problem with the Json</h2>"
result = DB_handler.create_user(data)
print(result)
# test
return json.dumps(result)
except Exception as e:
print("exception")
return render_template('Form.html', error=error)
def retrieve():
first_name = ent_first_name.get()
last_name = ent_last_name.get()
valid_start_time = parse_date_time_input(ent_date, ent_hour, ent_minute)
transaction_time = parse_date_time_input(ent_date_view, ent_hour_view,
ent_minute_view)
if var.get():
transaction_time = datetime.now()
if validate_not_empty(first_name) and \
validate_not_empty(last_name) and \
valid_start_time != "" and \
transaction_time != "":
print("hello")
answer = DB_handler.retrieve(first_name=first_name,
last_name=last_name,
valid_start_time=valid_start_time,
transaction_time=transaction_time,
limit=1)
create_popup(answer=answer)
class SndIdxForm_handler(QDialog, SndIdxFormClass):
def __init__(self):
super().__init__()
# 폼 설정
self.setupUi(self)
# 전역변수
global isRcv # 수신중여부
isRcv = False
# 객체변수 설정
self.gAPIH = None # API 핸들러
self.gSckt = None # 송신소켓 핸들러
self.gDBH = None # DB 핸들러
# 버튼이벤트 핸들러 설정
self.btnRcvIdx.clicked.connect(self.ClickRcvIdx) # 지수수신시작 버튼
self.btnStopRcvIdx.clicked.connect(self.ClickStopRcvIdx) # 지수수신종료 버튼
self.btnInitQttn.clicked.connect(self.ClickInitQttn) # 지수수시세 초기화 버튼
# 상태표시
self.edtStat.setText("시작전")
# API 초기화
try:
self.gAPIH = TradarAPI_handler()
#self.gAPIH = GlobalAPI_handler()
self.gAPIH.initAPI(True, self) # 전송모드 초기화
print("TRADAR end ")
except Exception as e:
print(e)
# 전송소켓 초기화
self.gSckt = SndSckt_handler()
# DB 핸들러 초기화
self.gDBH = DB_handler()
# 지수최근 동기화일자 표시
self.SetLastDtMn()
return None
def __del__(self):
print("dddd")
try:
# API 종료
self.APIH.CloseAPI()
# 소켓종료
if (self.gSckt.GetOnSock() == True):
self.gSckt.ClseSckt()
except Exception as e:
print("종료에러:", e)
return None
# 지수수신처리 시작
def ClickRcvIdx(self):
global isRcv
if (isRcv):
# 나중에 종목별로 제어할것
ctypes.windll.user32.MessageBoxW(0, "이미 실시간시세 등록된 종목입니다.", "알림", 0)
return None
isRcv = True
# 소켓연결
try:
if (self.gSckt.GetOnSock() == False):
self.gSckt.CnntSckt(CodeDef.PORT_INDEX_QTTN)
except Exception as e:
print("전송소켓 연결 실패 에러 :", e)
return None
# 데이터 요청
self.edtStat.setText("수신중")
self.gAPIH.OnRequest("REAL_QTTN", "11", CodeDef.INDEX_STK_CD)
#self.gAPIH.OnRequest("REAL_QTTN", "61", "ESM18")
return None
# 지수수신처리 종료
def ClickStopRcvIdx(self):
global isRcv
if (isRcv):
# 데이터 요청중지
self.edtStat.setText("수신종료 중")
self.gAPIH.StopRealRcv(None, CodeDef.INDEX_STK_CD)
#self.gAPIH.StopRealRcv(None, "ESM18")
self.edtStat.setText("수신종료")
return None
# 실시간 시세전송]
# inStkCd : 종목코드
# inTime : 시각(HHMM)
# inCrPrc : 현재가/종가
# inFtPrc : 시가
# inHgPrc : 고가
# inLoPrc : 저가
def SendRealQttn(self, inStkCd, inTime, inCrPrc, inFtPrc, inHgPrc,
inLoPrc):
# 소켓전송
QttnInfo = inStkCd + "|" + inTime + "|" + inCrPrc + "|" + inFtPrc + "|" + inHgPrc + "|" + inLoPrc + "|E"
self.gSckt.SendData(QttnInfo)
return None
# 지수시세초기화 버튼
def ClickInitQttn(self):
Chk = ctypes.windll.user32.MessageBoxW(0, "초기화 시작합니다.", "알림", 1)
if (Chk == 2):
return None
try:
StrDt = ""
StrMn = ""
# 최근 동기화일 가져옴
MaxLastDtMn = self.gDBH.queryKospiLastDtMn(CodeDef.INDEX_STK_CD)
RowCnt = len(MaxLastDtMn.index)
if (RowCnt == 0):
StrDt = CodeDef.INIT_STR_DT_DEFAULT
StrMn = CodeDef.INIT_STR_MN_DEFAULT
else:
StrDt = MaxLastDtMn.iat[0, 1]
StrMn = MaxLastDtMn.iat[0, 2]
if (StrDt is None or len(StrDt) == 0):
StrDt = CodeDef.INIT_STR_DT_DEFAULT
if (StrMn is None or len(StrMn) == 0):
StrMn = CodeDef.INIT_STR_MN_DEFAULT
print("초기화 시작:", CodeDef.INDEX_STK_CD, StrDt, StrMn,
CodeDef.INIT_END_DT_DEFAULT, CodeDef.INIT_END_MN_DEFAULT)
# 기존데이터 삭제
self.gDBH.deleteMnQttn("KOSPI", CodeDef.INDEX_STK_CD, StrDt, StrMn,
CodeDef.INIT_END_DT_DEFAULT,
CodeDef.INIT_END_MN_DEFAULT)
# 데이터 수신 (빈분봉이 없기 때문에 따로 분봉채우기를 할 필요가 없다.)
self.gAPIH.InitMnQttn(CodeDef.MKT_TP_CD_INTERNAL,
CodeDef.INDEX_STK_CD, StrDt, StrMn,
CodeDef.INIT_END_DT_DEFAULT,
CodeDef.INIT_END_MN_DEFAULT)
print("초기화 종료")
except Exception as e:
print("KOSPI 시세 초기화 에러:", e)
return None
# 최근동기화 표시
self.SetLastDtMn()
ctypes.windll.user32.MessageBoxW(0, "초기화 완료되었습니다.", "알림", 0)
return None
# 최근 지수 동기화일자 표시
def SetLastDtMn(self):
MaxLastDtMn = self.gDBH.queryKospiLastDtMn(CodeDef.INDEX_STK_CD)
RowCnt = len(MaxLastDtMn.index)
if (RowCnt == 0):
self.edtLastDtMn.setText("데이터 없음")
else:
LastDt = MaxLastDtMn.iat[0, 1]
LastMn = MaxLastDtMn.iat[0, 2]
if (LastDt is None or len(LastDt) == 0):
self.edtLastDtMn.setText("데이터 없음")
else:
self.edtLastDtMn.setText(LastDt + "-" + LastMn)
return None
class TestQttn_Sender(threading.Thread):
def __init__(self, inForm):
threading.Thread.__init__(self)
self.daemon = True
# 테스트 시세 수신제어
global isTestQttnRunning
# 진행시세 index
global qIndex
qIndex = 0
# 데이터 준비 확인
global existTestQttn
existTestQttn = False
# 시세 종목리스트
global QttnStkList
# 테스트시세
global SavedQttnList
global SavedQttnCnt
SavedQttnList = None
SavedQttnCnt = 0
# 메인폼
self.MainForm = inForm
# DB 핸들러
self.DBH = DB_handler()
# 시세종목리스트 초기화
QttnStkList = self.MainForm.GetProcStkList()
QttnStkList.insert(0, CodeDef.INDEX_STK_CD)
# 테스트시세준비
SavedQttnList = self.DBH.querySavedTestQttn()
SavedQttnCnt = len(SavedQttnList.index)
print("테스트 시세 조회완료")
return None
def run(self):
global isTestQttnRunning
global qIndex
global SavedQttnList
global SavedQttnCnt
global QttnStkList
global QttnStkCnt
global existTestQttn
# 루프 돌면서 클라이언트로 들어온 데이터 그대로 재 전송
isTestQttnRunning = True
while (1):
# 전문 구성 및 전송
for idx in range(qIndex, SavedQttnCnt):
time.sleep(1)
SavedQttn = SavedQttnList.iloc[idx].tolist()
SndData = "QTTN_TEST|"
Mn = int(SavedQttn.pop(1)) # 시각
KospiQttn = None
for qIdx in range(len(SavedQttn)):
SndData = SndData + QttnStkList[qIdx] + "|" + str(
Mn).zfill(4) + "|" + str(SavedQttn[qIdx]) + "|0|0|0|E|"
if (QttnStkList[qIdx] == CodeDef.INDEX_STK_CD):
KospiQttn = CodeDef.INDEX_STK_CD + "|" + str(Mn).zfill(
4) + "|" + str(SavedQttn[qIdx]) + "|0|0|0|E|END"
# 딥러닝에 전송
SndData = SndData + "END"
self.MainForm.SendTensorFlow(SndData)
qIndex = idx
#print("테스트시세 qIndex, SndData:",qIndex,SndData)
# 현 ETF 시세는 주가주신으로 처리함.
self.MainForm.ProcRcvRealQttn("KOSPI_INDEX", KospiQttn)
while (isTestQttnRunning == False):
time.sleep(1)
#print("테스트 시세 대기중")
print("테스트 시세 Loop 종료됨")
return None
# 수신 중지
def DoStop(self):
global isTestQttnRunning
isTestQttnRunning = False
print("테스트 시세수신 종료!!!")
return None
# 수신 재시작
def DoRestart(self):
global isTestQttnRunning
isTestQttnRunning = True
print("테스트 시세수신 재시작!!!")
return None
def __init__(self):
super().__init__()
# 폼 설정
self.setupUi(self)
# 시세 변수 초기화
self.StkList = [] # 처리종목 리스트
self.CrPrcDict = {} # 현재가/종가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.FtPrcDict = {} # 시가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.HgPrcDict = {} # 고가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.LoPrcDict = {} # 저가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.CurMn = datetime.today().strftime("%H%M") # 처리현재시각(HHMM)
# 변수 초기화
self.SndSckt = None # 송신소켓 핸들러
self.RcvSckt = None # 수신소켓 핸들러
self.isRcv = False # 수신상태
self.DBH = None # DB 핸들러
self.TFH = None # 텐서플로우 핸들러
# 버튼이벤트 핸들러 설정
self.btnRcvData.clicked.connect(self.ClickRcvData) # 데이터수신 버튼
#self.btnTrmsData.clicked.connect(self.ClickTrmsData) # 데이터송신 버튼
self.btnDoLearning.clicked.connect(self.ClickDoLearning) # 학습수행 버튼
# 소켓 초기화
self.SndSckt = SndSckt_handler()
self.RcvSckt = RcvSckt_handler(self, CodeDef.PORT_TF_DATA)
# 상태표시
self.edtStat.setText("시작전")
# 필요폴더 확인 및 생성, 로그삭제
self.InitFolder()
# DB 핸들러 초기화
self.DBH = DB_handler()
# TensorFlow 핸들러 초기화
self.TFH = TensorFlow_handler(self, self.DBH)
# 학습기간입력 초기화
self.dteStrDtMn.setCalendarPopup(True)
self.dteStrDtMn.setDisplayFormat("yyyy-MM-dd hh:mm")
StrDtMn = QtCore.QDateTime(
int(CodeDef.TF_LEARNING_STR_DT[:4]) # 년
,
int(CodeDef.TF_LEARNING_STR_DT[4:6]) # 월
,
int(CodeDef.TF_LEARNING_STR_DT[6:]) # 일
,
int(CodeDef.TF_LEARNING_STR_MN[:2]) # 시
,
int(CodeDef.TF_LEARNING_STR_MN[2:]) # 분
,
0)
self.dteStrDtMn.setDateTime(StrDtMn)
self.dteEndDtMn.setCalendarPopup(True)
self.dteEndDtMn.setDisplayFormat("yyyy-MM-dd hh:mm")
EndDtMn = QtCore.QDateTime(
int(CodeDef.TF_LEARNING_END_DT[:4]) # 년
,
int(CodeDef.TF_LEARNING_END_DT[4:6]) # 월
,
int(CodeDef.TF_LEARNING_END_DT[6:]) # 일
,
int(CodeDef.TF_LEARNING_END_MN[:2]) # 시
,
int(CodeDef.TF_LEARNING_END_MN[2:]) # 분
,
0)
self.dteEndDtMn.setDateTime(EndDtMn)
# 텐서플로 처리 종목 초기화 ( 입력순서순 정렬되어 있음 )
# KODEX 레버지리 추가
self.StkList = list(self.DBH.queryProcStkList()["STK_CD"])
self.StkList.insert(0, CodeDef.INDEX_STK_CD)
#print("처리종목확인:",self.StkList)
# 예측처리 작동확인
#P_Value = self.TFH.DoPrediction([[120.234375, 105.9453125, 113.6640625, 0.7349, 2721.5, 1249.9, 297.15, 7061.25]]);
#print("예측동작확인:", P_Value)
# 예측분 리스트 정보
self.PredMnList = CodeDef.TF_LEARNING_MN_LIST # 예측분 리스트
self.PredMnCnt = len(self.PredMnList)
# 예측분 시각을 가져오기 위한 임시 일자
self.TempDt = datetime(year=2000, month=1, day=1, hour=1, minute=1)
# 예측분 계산을 위한 TimeDelta 리스트
self.PredTimeDeltaList = []
for idx in range(self.PredMnCnt):
self.PredTimeDeltaList.append(
timedelta(minutes=self.PredMnList[idx]))
# 실시간 예측결과 엑셀저장 초기화
NewRlstFile = False
self.PredSaveFile = None
try:
self.PredSaveFile = load_workbook(CodeDef.TF_PREDICTION_SAVE_FILE)
except Exception as e:
print("실시간시세결과저장엑셀오픈에러:", e)
self.PredSaveFile = Workbook()
NewRlstFile = True
print("엑셀파일 재생성완료")
self.PredWrkSheet = self.PredSaveFile.active
self.PredCellPos = 1
self.PredWrkSheet.cell(row=1,
column=1,
value=datetime.today().strftime("%Y%m%d"))
if (NewRlstFile):
self.PredWrkSheet.cell(row=2, column=1, value="Time")
self.PredWrkSheet.cell(row=2, column=2, value="RealPrice")
for idx in range(self.PredMnCnt):
self.PredWrkSheet.cell(row=2,
column=(idx + 3),
value=("Prediction_" +
str(self.PredMnList[idx])))
self.PredSaveFile.save(CodeDef.TF_PREDICTION_SAVE_FILE)
self.PredCellPos = 3
else:
for row in self.PredWrkSheet.rows:
self.PredCellPos = self.PredCellPos + 1
if (row[0].value is None):
break
return None
class TFMainForm_handler(QDialog, TFMainFormClass):
def __init__(self):
super().__init__()
# 폼 설정
self.setupUi(self)
# 시세 변수 초기화
self.StkList = [] # 처리종목 리스트
self.CrPrcDict = {} # 현재가/종가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.FtPrcDict = {} # 시가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.HgPrcDict = {} # 고가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.LoPrcDict = {} # 저가 딕셔너리 {(종목코드,시각): 현재가/종가 }
self.CurMn = datetime.today().strftime("%H%M") # 처리현재시각(HHMM)
# 변수 초기화
self.SndSckt = None # 송신소켓 핸들러
self.RcvSckt = None # 수신소켓 핸들러
self.isRcv = False # 수신상태
self.DBH = None # DB 핸들러
self.TFH = None # 텐서플로우 핸들러
# 버튼이벤트 핸들러 설정
self.btnRcvData.clicked.connect(self.ClickRcvData) # 데이터수신 버튼
#self.btnTrmsData.clicked.connect(self.ClickTrmsData) # 데이터송신 버튼
self.btnDoLearning.clicked.connect(self.ClickDoLearning) # 학습수행 버튼
# 소켓 초기화
self.SndSckt = SndSckt_handler()
self.RcvSckt = RcvSckt_handler(self, CodeDef.PORT_TF_DATA)
# 상태표시
self.edtStat.setText("시작전")
# 필요폴더 확인 및 생성, 로그삭제
self.InitFolder()
# DB 핸들러 초기화
self.DBH = DB_handler()
# TensorFlow 핸들러 초기화
self.TFH = TensorFlow_handler(self, self.DBH)
# 학습기간입력 초기화
self.dteStrDtMn.setCalendarPopup(True)
self.dteStrDtMn.setDisplayFormat("yyyy-MM-dd hh:mm")
StrDtMn = QtCore.QDateTime(
int(CodeDef.TF_LEARNING_STR_DT[:4]) # 년
,
int(CodeDef.TF_LEARNING_STR_DT[4:6]) # 월
,
int(CodeDef.TF_LEARNING_STR_DT[6:]) # 일
,
int(CodeDef.TF_LEARNING_STR_MN[:2]) # 시
,
int(CodeDef.TF_LEARNING_STR_MN[2:]) # 분
,
0)
self.dteStrDtMn.setDateTime(StrDtMn)
self.dteEndDtMn.setCalendarPopup(True)
self.dteEndDtMn.setDisplayFormat("yyyy-MM-dd hh:mm")
EndDtMn = QtCore.QDateTime(
int(CodeDef.TF_LEARNING_END_DT[:4]) # 년
,
int(CodeDef.TF_LEARNING_END_DT[4:6]) # 월
,
int(CodeDef.TF_LEARNING_END_DT[6:]) # 일
,
int(CodeDef.TF_LEARNING_END_MN[:2]) # 시
,
int(CodeDef.TF_LEARNING_END_MN[2:]) # 분
,
0)
self.dteEndDtMn.setDateTime(EndDtMn)
# 텐서플로 처리 종목 초기화 ( 입력순서순 정렬되어 있음 )
# KODEX 레버지리 추가
self.StkList = list(self.DBH.queryProcStkList()["STK_CD"])
self.StkList.insert(0, CodeDef.INDEX_STK_CD)
#print("처리종목확인:",self.StkList)
# 예측처리 작동확인
#P_Value = self.TFH.DoPrediction([[120.234375, 105.9453125, 113.6640625, 0.7349, 2721.5, 1249.9, 297.15, 7061.25]]);
#print("예측동작확인:", P_Value)
# 예측분 리스트 정보
self.PredMnList = CodeDef.TF_LEARNING_MN_LIST # 예측분 리스트
self.PredMnCnt = len(self.PredMnList)
# 예측분 시각을 가져오기 위한 임시 일자
self.TempDt = datetime(year=2000, month=1, day=1, hour=1, minute=1)
# 예측분 계산을 위한 TimeDelta 리스트
self.PredTimeDeltaList = []
for idx in range(self.PredMnCnt):
self.PredTimeDeltaList.append(
timedelta(minutes=self.PredMnList[idx]))
# 실시간 예측결과 엑셀저장 초기화
NewRlstFile = False
self.PredSaveFile = None
try:
self.PredSaveFile = load_workbook(CodeDef.TF_PREDICTION_SAVE_FILE)
except Exception as e:
print("실시간시세결과저장엑셀오픈에러:", e)
self.PredSaveFile = Workbook()
NewRlstFile = True
print("엑셀파일 재생성완료")
self.PredWrkSheet = self.PredSaveFile.active
self.PredCellPos = 1
self.PredWrkSheet.cell(row=1,
column=1,
value=datetime.today().strftime("%Y%m%d"))
if (NewRlstFile):
self.PredWrkSheet.cell(row=2, column=1, value="Time")
self.PredWrkSheet.cell(row=2, column=2, value="RealPrice")
for idx in range(self.PredMnCnt):
self.PredWrkSheet.cell(row=2,
column=(idx + 3),
value=("Prediction_" +
str(self.PredMnList[idx])))
self.PredSaveFile.save(CodeDef.TF_PREDICTION_SAVE_FILE)
self.PredCellPos = 3
else:
for row in self.PredWrkSheet.rows:
self.PredCellPos = self.PredCellPos + 1
if (row[0].value is None):
break
return None
def __del__(self):
# 송신소켓종료
if (self.SndSckt.GetOnSock() == True):
self.SndSckt.ClseSckt()
# 수신소켓종료
if (self.isRcv):
print("데이터 수신 쓰레드 중지 시작")
self.RcvSckt.DoStop()
self.RcvSckt.join()
# 실시간예측저장엑셀 종료
self.PredSaveFile.close()
return None
# 데이터수신처리 시작
def ClickRcvData(self):
# 중지실행
if (self.isRcv):
print("데이터 수신 쓰레드 중지 시작")
try:
self.RcvSckt.DoStop()
self.RcvSckt.join()
except Exception as e:
print("데이터 수신 쓰레드 중지 에러: ", e)
return None
self.isRcv = False
self.edtStat.setText("시작전")
self.btnRcvData.setText("데이터수신시작")
self.btnRcvData.setStyleSheet("background-color:None")
print("데이터 수신 쓰레드 종료됨.")
# 받기시작
else:
try:
self.RcvSckt.start()
except Exception as e:
print("데이터 수신 쓰레드 시작 에러 :", e)
return None
self.isRcv = True
self.edtStat.setText("데이터수신중")
self.btnRcvData.setText("데이터수신종료")
self.btnRcvData.setStyleSheet("background-color:rgb(255,020,147)")
print("데이터 수신 Loop 시작됨.")
return None
# 수신 데이터 처리
# inData : 수신 테이터 (QTTN|종목코드|시각(HHMM)|현재or종가|시가|고가|저가|E|종목코드....|END)
def ProcRcvRealQttn(self, inProcTp, inData):
self.dispText("시세수신:" + inData)
RcvData = inData.split("|")
ProcTp = RcvData[0] # 처리구분
del RcvData[0]
DataCnt = len(RcvData)
print("처리구분 Cnt:", ProcTp, DataCnt)
# 시세 처리
if (ProcTp == "QTTN" or ProcTp == "QTTN_TEST"):
QttnIdx = 0
StkCd = ""
MN = ""
GetTFRslt = False
# 시세 파싱
# [종목코드, 시각(HHMM) , 현재or종가 , 시가 , 고가 , 저가 , E , 종목코드.... , END]
for i in range(DataCnt):
Data = RcvData.pop(0)
# 종료확인
if (Data == "END"):
break
else:
# 종목코드
if (QttnIdx == CodeDef.REAL_QTTN_COL_STK_CD):
StkCd = Data
# 시각(HHMM)
elif (QttnIdx == CodeDef.REAL_QTTN_COL_TIME):
MN = Data
# 시세 시각이 변동될시 예측 시작
if (int(MN) > int(self.CurMn)
or ProcTp == "QTTN_TEST"):
GetTFRslt = True
# 현재가/종가
elif (QttnIdx == CodeDef.REAL_QTTN_COL_CRPRC):
self.CrPrcDict[(StkCd, MN)] = float(Data)
# 시가
elif (QttnIdx == CodeDef.REAL_QTTN_COL_FTPRC):
self.FtPrcDict[(StkCd, MN)] = float(Data)
# 고가
elif (QttnIdx == CodeDef.REAL_QTTN_COL_HGPRC):
self.HgPrcDict[(StkCd, MN)] = float(Data)
# 저가
elif (QttnIdx == CodeDef.REAL_QTTN_COL_LOPRC):
self.LoPrcDict[(StkCd, MN)] = float(Data)
# 1개 종목 시세 종료
if (Data == "E"):
#if (QttnIdx == CodeDef.REAL_QTTN_COL_END):
QttnIdx = 0
else:
QttnIdx += 1
# ---- 시세파싱 for문 종료 -------
if (GetTFRslt):
print("시간이동으로 예측시작! self.CurMn, MN, GetTFRslt:", self.CurMn,
MN, GetTFRslt)
self.GetRsltDeepLearning(self.CurMn)
self.CurMn = MN
print("시간이동으로 예측종료")
# ---- ProcTp == "QTTN" 종료 -------
elif (ProcTp == "TEST"):
print("ProcTp : TEST")
else:
print("ProcTp 설정 오류: ", ProcTp)
return None
return None
# 학습시작
def ClickDoLearning(self):
try:
StrDtMn = self.dteStrDtMn.dateTime().toString("yyyyMMddhhmm")
EndDtMn = self.dteEndDtMn.dateTime().toString("yyyyMMddhhmm")
if (len(StrDtMn) != 12 or len(EndDtMn) != 12):
ctypes.windll.user32.MessageBoxW(0, "기간입력형식이 잘못되었습니다.", "입력오류",
0)
return None
if (int(StrDtMn) >= int(EndDtMn)):
ctypes.windll.user32.MessageBoxW(0, "시작일시가 더 큽니다.", "입력오류", 0)
return None
# 예측분별 학습
for idx in range(len(CodeDef.TF_LEARNING_MN_LIST)):
print(str(CodeDef.TF_LEARNING_MN_LIST[idx]) + "분 예측 학습시작")
self.TFH.DoLearning(StrDtMn, EndDtMn, idx)
ctypes.windll.user32.MessageBoxW(0, "학습종료 및 테스트결과 저장완료", "학습종료", 0)
except Exception as e:
print("학습수행 클릭에러:", e)
return None
# 딥러닝 결과 가져오기
# inMn : 처리대상 시각(HHMM)
def GetRsltDeepLearning(self, inMn):
# 예측을 위한 시세 리스트
Qttn = []
# 인덱스 현재가
KospiPrc = 0.0
StkCnt = len(self.StkList)
for idx in range(StkCnt):
StkCd = self.StkList[idx]
# 입력데이터 설정
#print("self.CrPrcDict:",self.CrPrcDict)
if ((StkCd, inMn) in self.CrPrcDict):
CrPrc = self.CrPrcDict[(StkCd, inMn)]
Qttn.append(CrPrc)
# KODEX 레버리지현재가 다음은 시분
if (StkCd == CodeDef.INDEX_STK_CD):
Qttn.append(float(inMn))
KospiPrc = CrPrc
# 한종목이라도 값이없다면 예측할수없다.
else:
print("시세생성전이라 불가 StkCd, idx, inMn: ", StkCd, idx, inMn)
return None
#CrPrc = self.CrPrcDict[(StkCd, inMn)]
#FtPrc = self.FtPrcDict[(StkCd, inMn)]
#HgPrc = self.HgPrcDict[(StkCd, inMn)]
#LoPrc = self.LoPrcDict[(StkCd, inMn)]
print("예측수행!!!: ", inMn, Qttn)
# 예측치 가져오기
inPutX = []
inPutX.append(Qttn)
for idx in range(self.PredMnCnt):
# 미래시간계산. 장시간을 벗어나면 Pass
NextMn = self.GetNextMn(inMn, idx)
if (int(NextMn) > 1519):
print("예측시간 오버 예측미수행 NextMn:", NextMn)
P_Value = 0.0
continue
P_Value = self.TFH.DoPrediction(inPutX, idx)
# list형 리턴
print("예측결과!!![" + str(self.PredMnList[idx]) + "분]:", NextMn,
P_Value)
if (P_Value == 0.0):
print("예측값오류 패스 P_Value:", P_Value)
continue
#self.dispText("예측결과!!!:" + NextMn +"|" + str(P_Value))
# 결과값 전송
if (self.SndSckt.GetOnSock() == False):
self.SndSckt.CnntSckt(CodeDef.PORT_TF_RCV_RSLT)
# 예측분|예측시각|값
SndData = str(self.PredMnList[idx]) + "|" + NextMn + "|" + str(
P_Value) + "|E|"
print("SndData:", SndData)
self.SndSckt.SendData(SndData)
# 결과값 저장
self.PredWrkSheet.cell(row=self.PredCellPos, column=1, value=inMn)
self.PredWrkSheet.cell(row=self.PredCellPos,
column=2,
value=KospiPrc)
self.PredWrkSheet.cell(row=(self.PredCellPos +
self.PredMnList[idx]),
column=(idx + 3),
value=P_Value)
self.PredSaveFile.save(CodeDef.TF_PREDICTION_SAVE_FILE)
# 결과저장 엑셀 Row 인덱스 증가
self.PredCellPos = self.PredCellPos + 1
return P_Value
# 다음 시분 가져오기
# inStdMn : 기준시분(HHMM)
# inPredMnIdx : 예측분 인덱스
def GetNextMn(self, inStdMn, inPredMnIdx):
NextMn = ""
iM = int(inStdMn[:2])
iN = int(inStdMn[2:])
self.TempDt = self.TempDt.replace(hour=iM, minute=iN)
NextMn = (self.TempDt +
self.PredTimeDeltaList[inPredMnIdx]).strftime("%H%M")
return NextMn
# 출력창 출력
def dispText(self, inText):
self.edtTest.append(inText)
return None
# 학습저장초기화 체크박스 값 가져오기
def GetInitSave(self):
return self.chkInitSave.isChecked()
# 필요 폴더 확인 및 생성
def InitFolder(self):
# 학습테스트 결과폴더
if not os.path.exists(CodeDef.TF_LEARNING_RSLT_DIR):
os.mkdir(CodeDef.TF_LEARNING_RSLT_DIR)
# 학습로그 폴더
if not os.path.exists(CodeDef.TF_LEARNING_LOG_DIR):
os.mkdir(CodeDef.TF_LEARNING_LOG_DIR)
# 학습결과 폴더
if not os.path.exists(CodeDef.TF_LEARNING_SAVE_MAINDIR):
os.mkdir(CodeDef.TF_LEARNING_SAVE_MAINDIR)
# 학습결과 폴더 : 예측분별
for idx in range(len(CodeDef.TF_LEARNING_MN_LIST)):
Dir = CodeDef.TF_LEARNING_SAVE_DIR + str(
CodeDef.TF_LEARNING_MN_LIST[idx])
if not os.path.exists(Dir):
os.mkdir(Dir)
# 실시간 예측결과 저장 폴더
if not os.path.exists(CodeDef.TF_PREDICTION_SAVE_DIR):
os.mkdir(CodeDef.TF_PREDICTION_SAVE_DIR)
# 로그파일삭제
FilePath = os.path.dirname(os.path.abspath(__file__)) + "\TrainingLog"
FileNmlist = None
for dirN, subDirN, fileN in os.walk(FilePath):
FileNmlist = fileN
for idx in range(len(FileNmlist)):
os.remove(FilePath + "\\" + FileNmlist[idx])
return None
import json
import DB_handler
user2 = '''{"user_info": {"user_name": "tom", "user_email": "*****@*****.**", "user_password": "******"}}'''
user = '''{"user_info": {"user_name": "ido", "user_email": "*****@*****.**", "user_password": "******"}}'''
user3 = '''{"user_info": {"user_name": "gadi", "user_email": "*****@*****.**", "user_password": "******"}}'''
user4 = '''{"user_info": {"user_name": "ido", "user_email": "*****@*****.**", "user_password": "******"}}'''
# show = '''{"show_info": {"artist_name": "static & benEl", "location": "zapa tel-aviv", "date": "25.6.2018","price":"350"}}'''
show2 = '''{"show_info": {"artist_name": "omer adam", "location": "beer-sheva", "date": "20180518","price":"450"}}'''
show3 = '''{"show_info": {"artist_name": "mosh-ben-ari", "location": "eilat", "date": "20180614","price":"150"}}'''
# userToDelete = '''{"delete_info": {"user_name": "tom","user_password": "******"}}'''
# userToDelete_json = json.loads(userToDelete)
# user_4 = json.loads(user4)
# DB_handler.create_user(user_4)
login_ido = '''{"user_info": {"user_email": "*****@*****.**", "user_password": "******"}}'''
login_json = json.loads(login_ido)
result = DB_handler.user_login(login_json)
print(result)
from openpyxl import load_workbook, Workbook
from pandas import DataFrame
from DB_handler import *
sFile = None
DBH = None
inList = []
try:
print("환율엑셀로딩시작")
sFile = load_workbook(
"C:\YT_DeepLearningProject\YT_Prediction\Test_exr.xlsx")
print("환율엑셀로딩끝")
DBH = DB_handler()
except Exception as e:
print("초기화 에러:", e)
exit()
sSheet = sFile.active
print("입력시작")
idx = 0
for row in sSheet.rows:
if (row[0].value is None):
break
# print(type(row[0].value),type(row[1].value),type(row[2].value),type(row[3].value),type(row[4].value),type(row[5].value))
dt = str(row[0].value)
hm = str(row[1].value).zfill(4)
ft = row[2].value
hg = row[3].value
lo = row[4].value
cl = row[5].value