dsyoon/DeepStock
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
dsyoon
2021-09-18 03:01:55 +09:00
parent c4cda59eb8
commit 3fdfc7c8fc
3 changed files with 3648 additions and 473 deletions
Download Patch File Download Diff File Expand all files Collapse all files

450
hts/FiveMinutes.py
View File

@@ -1,450 +0,0 @@
import sys
from PyQt5.QtWidgets import *
import win32com.client
import ctypes
import time
################################################
# PLUS 공통 OBJECT
g_objCodeMgr = win32com.client.Dispatch('CpUtil.CpCodeMgr')
g_objCpStatus = win32com.client.Dispatch('CpUtil.CpCybos')
g_objCpTrade = win32com.client.Dispatch('CpTrade.CpTdUtil')
################################################
# PLUS 실행 기본 체크 함수
def InitPlusCheck():
# 프로세스가 관리자 권한으로 실행 여부
if ctypes.windll.shell32.IsUserAnAdmin():
print('정상: 관리자권한으로 실행된 프로세스입니다.')
else:
print('오류: 일반권한으로 실행됨. 관리자 권한으로 실행해 주세요')
return False
# 연결 여부 체크
if (g_objCpStatus.IsConnect == 0):
print("PLUS가 정상적으로 연결되지 않음. ")
return False
# 주문 관련 초기화
if (g_objCpTrade.TradeInit(0) != 0):
print("주문 초기화 실패")
return False
return True
################################################
# CpEvent: 실시간 이벤트 수신 클래스
class CpEvent:
def set_params(self, client, name, caller):
self.client = client # CP 실시간 통신 object
self.name = name # 서비스가 다른 이벤트를 구분하기 위한 이름
self.caller = caller # callback 을 위해 보관
def OnReceived(self):
# 실시간 처리 - 현재가 체결 데이터
if self.name == 'stockcur':
code = self.client.GetHeaderValue(0) # 초
name = self.client.GetHeaderValue(1) # 초
timess = self.client.GetHeaderValue(18) # 초
exFlag = self.client.GetHeaderValue(19) # 예상체결 플래그
cprice = self.client.GetHeaderValue(13) # 현재가
diff = self.client.GetHeaderValue(2) # 대비
cVol = self.client.GetHeaderValue(17) # 순간체결수량
vol = self.client.GetHeaderValue(9) # 거래량
if exFlag != ord('2'):
return
item = {}
item['code'] = code
item['time'] = timess
item['diff'] = diff
item['cur'] = cprice
item['vol'] = cVol
# 현재가 업데이트
self.caller.updateCurData(item)
return
################################################
# plus 실시간 수신 base 클래스
class CpPublish:
def __init__(self, name, serviceID):
self.name = name
self.obj = win32com.client.Dispatch(serviceID)
self.bIsSB = False
def Subscribe(self, var, caller):
if self.bIsSB:
self.Unsubscribe()
if (len(var) > 0):
self.obj.SetInputValue(0, var)
handler = win32com.client.WithEvents(self.obj, CpEvent)
handler.set_params(self.obj, self.name, caller)
self.obj.Subscribe()
self.bIsSB = True
def Unsubscribe(self):
if self.bIsSB:
self.obj.Unsubscribe()
self.bIsSB = False
################################################
# CpPBStockCur: 실시간 현재가 요청 클래스
class CpPBStockCur(CpPublish):
def __init__(self):
super().__init__('stockcur', 'DsCbo1.StockCur')
# MACD 지표 계산
class CMACD:
def __init__(self):
self.objSeries = win32com.client.Dispatch("CpIndexes.CpSeries")
self.objIndex = win32com.client.Dispatch("CpIndexes.CpIndex")
# 차트 데이터 세팅 하기
def setChartData(self, chartData):
nLen = len(chartData['T'])
for i in range(nLen):
self.objSeries.Add(chartData['C'][i], chartData['O'][i], chartData['H'][i], chartData['L'][i],
chartData['V'][i])
return
# 기존 차트 데이터에 새로 들어온 신규 데이터 추가
def addLastData(self, chartData):
self.objSeries.Add(chartData['C'][-1], chartData['O'][-1], chartData['H'][-1], chartData['L'][-1],
chartData['V'][-1])
# MACD 계산
def makeMACD(self):
result = {}
# 지표 계산 object
self.objIndex.series = self.objSeries
self.objIndex.put_IndexKind("MACD") # 계산할 지표: MACD
self.objIndex.put_IndexDefault("MACD") # MACD 지표 기본 변수 자동 세팅
print("MACD 변수", self.objIndex.get_Term1(), self.objIndex.get_Term2(), self.objIndex.get_Signal())
# 지표 데이터 계산 하기
self.objIndex.Calculate()
cntofIndex = self.objIndex.ItemCount
print("지표 개수: ", cntofIndex)
indexName = ["MACD", "SIGNAL", "OSC"]
result['MACD'] = []
result['SIGNAL'] = []
result['OSC'] = []
for index in range(cntofIndex):
cnt = self.objIndex.GetCount(index)
for j in range(cnt):
value = self.objIndex.GetResult(index, j)
result[indexName[index]].append(value)
# for j in range(cnt) :
# value = self.objIndex.GetResult(index,j)
# print(indexName[index], value) # 지표의 최근 값 표시
print('MACD %.2f SIGNLA %.2f OSC %.2f' % (result['MACD'][-1], result['SIGNAL'][-1], result['OSC'][-1]))
return (True, result)
# MACD 업데이트(차트 데이터 개수에 변화가 없을 경우에만 사용)
def updateMACD(self, chartData):
result = {}
# 지표 데이터 update
self.objSeries.update(chartData['C'][-1], chartData['O'][-1], chartData['H'][-1], chartData['L'][-1],
chartData['V'][-1])
self.objIndex.update()
cntofIndex = self.objIndex.ItemCount
print("지표 개수: ", cntofIndex)
indexName = ["MACD", "SIGNAL", "OSC"]
result['MACD'] = []
result['SIGNAL'] = []
result['OSC'] = []
for index in range(cntofIndex):
cnt = self.objIndex.GetCount(index)
for j in range(cnt):
value = self.objIndex.GetResult(index, j)
result[indexName[index]].append(value)
print('MACD %.2f SIGNLA %.2f OSC %.2f' % (result['MACD'][-1], result['SIGNAL'][-1], result['OSC'][-1]))
return (True, result)
# 분차트 관리 클래스
# 주어진 주기로 분차트 조회 , 실시간 분차트 데이터 생성, MACD 계산 호출
class CMinchartData:
def __init__(self, interval):
# interval : 분차트 주기
self.interval = interval
self.objCur = {}
self.data = {}
self.code = ''
self.objMACD = CMACD()
self.LASTTIME = 1530
# 오늘 날짜
now = time.localtime()
self.todayDate = now.tm_year * 10000 + now.tm_mon * 100 + now.tm_mday
print(self.todayDate)
def MonCode(self, code):
self.data = {}
self.code = code
self.data['O'] = []
self.data['H'] = []
self.data['L'] = []
self.data['C'] = []
self.data['V'] = []
self.data['D'] = []
self.data['T'] = []
self.data['MACD'] = []
self.data['SIGNAL'] = []
self.data['OSC'] = []
# 차트 기본 통신
self.rqChartMinData(code, self.interval)
# MACD 클래스에 수신 받은 차트 데이터 세팅
self.objMACD.setChartData(self.data)
# MACD 계산 하기
ret, result = self.objMACD.makeMACD()
self.data['MACD'] = result['MACD']
self.data['SIGNAL'] = result['SIGNAL']
self.data['OSC'] = result['OSC']
# 실시간 시세 요청
if (code not in self.objCur):
self.objCur[code] = CpPBStockCur()
self.objCur[code].Subscribe(code, self)
def stop(self):
for k, v in self.objCur.items():
v.Unsubscribe()
self.objCur = {}
# 분차트 - 코드, 주기, 개수
def rqChartMinData(self, code, interval):
objRq = win32com.client.Dispatch("CpSysDib.StockChart")
objRq.SetInputValue(0, code) # 종목 코드
objRq.SetInputValue(1, ord('2')) # 개수로 조회
objRq.SetInputValue(4, 500) # 통신 개수 - 500 개로 고정
objRq.SetInputValue(5, [0, 1, 2, 3, 4, 5, 8]) # 날짜,시간, 시가,고가,저가,종가,거래량
objRq.SetInputValue(6, ord('m')) # '차트 주가 - 분 데이터
objRq.SetInputValue(7, interval) # 차트 주기
objRq.SetInputValue(9, ord('1')) # 9 - 수정주가(char)
totlen = 0
objRq.BlockRequest()
rqStatus = objRq.GetDibStatus()
rqRet = objRq.GetDibMsg1()
print("통신상태", rqStatus, rqRet)
if rqStatus != 0:
exit()
len = objRq.GetHeaderValue(3)
print(totlen)
totlen += len
print("날짜", "시가", "고가", "저가", "종가", "거래량")
print("==============================================-")
for i in range(len):
day = objRq.GetDataValue(0, i)
time = objRq.GetDataValue(1, i)
open = objRq.GetDataValue(2, i)
high = objRq.GetDataValue(3, i)
low = objRq.GetDataValue(4, i)
close = objRq.GetDataValue(5, i)
vol = objRq.GetDataValue(6, i)
self.data['D'].append(day)
self.data['T'].append(time)
self.data['O'].append(open)
self.data['H'].append(high)
self.data['L'].append(low)
self.data['C'].append(close)
self.data['V'].append(vol)
# 수신된 역순으로 넣는다 -> 최근 날짜가 맨 뒤로 가도록
self.data['D'].reverse()
self.data['T'].reverse()
self.data['O'].reverse()
self.data['H'].reverse()
self.data['L'].reverse()
self.data['C'].reverse()
self.data['V'].reverse()
# 가격 실시간 변경 시 분차트 데이터 재 계산
def updateCurData(self, item):
time = item['time']
self.cur = cur = item['cur']
vol = item['vol']
self.makeMinchart(time, cur, vol)
def getHMTFromTime(self, time):
hh, mm = divmod(time, 10000)
mm, tt = divmod(mm, 100)
return (hh, mm, tt)
def getChartTime(self, time):
# time 600 (10:00 인 경우 600)
lChartTime = time + self.interval
# 630 ==> 1030 분으로 변경
hour, min = divmod(lChartTime, 60)
lCurTime = hour * 100 + min
if (lCurTime > self.LASTTIME):
lCurTime = self.LASTTIME
return lCurTime
# 실시간 데이터를 통해 분차트 업데이트
def makeMinchart(self, time, cur, vol):
# time 분해 ==> 시, 분, 초
hh, mm, tt = self.getHMTFromTime(time)
# hhmm = hh * 100 + mm
# 1000 ==> 600 분
converedMintime = hh * 60 + mm
bFind = False
nLen = len(self.data['T'])
# 분차트 주기 기준으로 나눠서 시간 차트 시간 계산
# 1분 봉의 경우 14:10분 봉: 14:09:00~14:09:59
# 5분 봉의 경우 14:10분 봉 : 14:05:00~ 14:09:59
a, b = divmod(converedMintime, self.interval)
intervaltime = a * self.interval
lCurTime = self.getChartTime(intervaltime)
print('차트 시간 계산 : 들어온 시간 %d, 차트 시간 %d' % (time, lCurTime))
if (nLen > 0):
lLastTime = self.data['T'][-1]
if (lLastTime == lCurTime):
bFind = True
self.data['C'][-1] = cur
if (self.data['H'][-1] < cur):
self.data['H'][-1] = cur
if (self.data['L'][-1] > cur):
self.data['L'][-1] = cur
self.data['V'][-1] += vol
print('들어온 시간 %d ==> 마지막 분차트 시간 %d 에 업데이트' % (time, lLastTime))
ret, result = self.objMACD.updateMACD(self.data)
self.data['MACD'] = result['MACD']
self.data['SIGNAL'] = result['SIGNAL']
self.data['OSC'] = result['OSC']
# 신규 봉이 추가
if bFind == False:
print('들어온 시간 %d ==> 새로운 분차트 시간 %d 에 업데이트' % (time, lCurTime))
self.data['D'].append(self.todayDate)
self.data['T'].append(lCurTime)
self.data['O'].append(cur)
self.data['H'].append(cur)
self.data['L'].append(cur)
self.data['C'].append(cur)
self.data['V'].append(vol)
# 데이터 추가 - MACD 계산 모듈에 차트 데이터 추가
self.objMACD.addLastData(self.data)
# MACD 계산
ret, result = self.objMACD.makeMACD()
self.data['MACD'] = result['MACD']
self.data['SIGNAL'] = result['SIGNAL']
self.data['OSC'] = result['OSC']
# MACD 의 신호가 교차됐는지 체크
self.checkMACD()
return
def checkMACD(self):
if (len(self.data['OSC']) < 5):
return
# 현재 시점에서 이전 봉(-2) 가 매수신호/매도 신호 발생했는 지 체크
# -1 : 현재 시점 -2: 바로 직전 봉 -3 그 전 봉
print('osc', self.data['OSC'][-3], self.data['OSC'][-2], self.data['OSC'][-1])
if self.data['OSC'][-3] < 0:
if self.data['OSC'][-2] > 0:
print('MACD 매수, 시간 %d, 가격 %d' % (self.data['T'][-1], self.data['C'][-1]))
elif self.data['OSC'][-3] > 0:
if self.data['OSC'][-2] < 0:
print('MACD 매도, 시간 %d, 가격 %d' % (self.data['T'][-1], self.data['C'][-1]))
def printdata(self):
nLen = len(self.data['T'])
for i in range(nLen):
print(self.data['D'][i],
self.data['T'][i],
self.data['O'][i],
self.data['H'][i],
self.data['L'][i],
self.data['C'][i],
self.data['V'][i],
self.data['MACD'][i],
self.data['SIGNAL'][i],
self.data['OSC'][i])
# print(code, self.minDatas[code])
################################################
# 테스트를 위한 메인 화면
class MyWindow(QMainWindow):
def __init__(self):
super().__init__()
# plus 상태 체크
if InitPlusCheck() == False:
exit()
self.minData = CMinchartData(5)
self.minData.MonCode('A069500')
self.setWindowTitle("주식 분 차트 생성")
self.setGeometry(300, 300, 300, 180)
nH = 20
btnPrint = QPushButton('print', self)
btnPrint.move(20, nH)
btnPrint.clicked.connect(self.btnPrint_clicked)
nH += 50
btnExit = QPushButton('종료', self)
btnExit.move(20, nH)
btnExit.clicked.connect(self.btnExit_clicked)
nH += 50
def btnPrint_clicked(self):
self.minData.printdata()
return
def btnExit_clicked(self):
self.minData.stop()
exit()
return
if __name__ == "__main__":
app = QApplication(sys.argv)
myWindow = MyWindow()
myWindow.show()
app.exec_()

2935
hts/HTS.py
View File

File diff suppressed because it is too large Load Diff

736
hts/RealTime.py Normal file
View File

@@ -0,0 +1,736 @@
import sys
import pandas
from PyQt5 import QtWidgets
from PyQt5.QtWidgets import *
from PyQt5 import uic
from PyQt5.QtCore import *
import win32com.client
from pandas import Series, DataFrame
import locale
# cp object
g_objCodeMgr = win32com.client.Dispatch("CpUtil.CpCodeMgr")
g_objCpStatus = win32com.client.Dispatch("CpUtil.CpCybos")
g_objCpTrade = win32com.client.Dispatch("CpTrade.CpTdUtil")
locale.setlocale(locale.LC_ALL, '')
# 현재가 정보 저장 구조체
class stockPricedData:
def __init__(self):
self.dicEx = {ord('0'): "동시호가/장중 아님", ord('1'): "동시호가", ord('2'): "장중"}
self.code = ""
self.name = ""
self.cur = 0 # 현재가
self.diff = 0 # 대비
self.diffp = 0 # 대비율
self.offer = [0 for _ in range(10)] # 매도호가
self.bid = [0 for _ in range(10)] # 매수호가
self.offervol = [0 for _ in range(10)] # 매도호가 잔량
self.bidvol = [0 for _ in range(10)] # 매수호가 잔량
self.totOffer = 0 # 총매도잔량
self.totBid = 0 # 총매수 잔량
self.vol = 0 # 거래량
self.tvol = 0 # 순간 체결량
self.baseprice = 0 # 기준가
self.high = 0
self.low = 0
self.open = 0
self.volFlag = ord('0') # 체결매도/체결 매수 여부
self.time = 0
self.sum_buyvol = 0
self.sum_sellvol = 0
self.vol_str = 0
# 예상체결가 정보
self.exFlag = ord('2')
self.expcur = 0 # 예상체결가
self.expdiff = 0 # 예상 대비
self.expdiffp = 0 # 예상 대비율
self.expvol = 0 # 예상 거래량
self.objCur = CpPBStockCur()
self.objOfferbid = CpPBStockBid()
def __del__(self):
self.objCur.Unsubscribe()
self.objOfferbid.Unsubscribe()
# 전일 대비 계산
def makediffp(self):
lastday = 0
if (self.exFlag == ord('1')): # 동시호가 시간 (예상체결)
if self.baseprice > 0:
lastday = self.baseprice
else:
lastday = self.expcur - self.expdiff
if lastday:
self.expdiffp = (self.expdiff / lastday) * 100
else:
self.expdiffp = 0
else:
if self.baseprice > 0:
lastday = self.baseprice
else:
lastday = self.cur - self.diff
if lastday:
self.diffp = (self.diff / lastday) * 100
else:
self.diffp = 0
def getCurColor(self):
diff = self.diff
if (self.exFlag == ord('1')): # 동시호가 시간 (예상체결)
diff = self.expdiff
if (diff > 0):
return 'color: red'
elif (diff == 0):
return 'color: black'
elif (diff < 0):
return 'color: blue'
# CpEvent: 실시간 이벤트 수신 클래스
class CpEvent:
def set_params(self, client, name, rpMst, parent):
self.client = client # CP 실시간 통신 object
self.name = name # 서비스가 다른 이벤트를 구분하기 위한 이름
self.parent = parent # callback 을 위해 보관
self.rpMst = rpMst
# PLUS 로 부터 실제로 시세를 수신 받는 이벤트 핸들러
def OnReceived(self):
if self.name == "stockcur":
# 현재가 체결 데이터 실시간 업데이트
self.rpMst.exFlag = self.client.GetHeaderValue(19) # 예상체결 플래그
code = self.client.GetHeaderValue(0)
diff = self.client.GetHeaderValue(2)
cur = self.client.GetHeaderValue(13) # 현재가
vol = self.client.GetHeaderValue(9) # 거래량
# 예제는 장중만 처리 함.
if (self.rpMst.exFlag == ord('1')): # 동시호가 시간 (예상체결)
# 예상체결가 정보
self.rpMst.expcur = cur
self.rpMst.expdiff = diff
self.rpMst.expvol = vol
else:
self.rpMst.cur = cur
self.rpMst.diff = diff
self.rpMst.makediffp()
self.rpMst.vol = vol
self.rpMst.open = self.client.GetHeaderValue(4)
self.rpMst.high = self.client.GetHeaderValue(5)
self.rpMst.low = self.client.GetHeaderValue(6)
self.rpMst.tvol = self.client.GetHeaderValue(17)
self.rpMst.volFlag = self.client.GetHeaderValue(14) # '1' 매수 '2' 매도
self.rpMst.time = self.client.GetHeaderValue(18)
self.rpMst.sum_buyvol = self.client.GetHeaderValue(16) # 누적매수체결수량 (체결가방식)
self.rpMst.sum_sellvol = self.client.GetHeaderValue(15) # 누적매도체결수량 (체결가방식)
if (self.rpMst.sum_sellvol):
self.rpMst.volstr = self.rpMst.sum_buyvol / self.rpMst.sum_sellvol * 100
else:
self.rpMst.volstr = 0
self.rpMst.makediffp()
# 현재가 업데이트
self.parent.monitorPriceChange()
return
elif self.name == "stockbid":
# 현재가 10차 호가 데이터 실시간 업데이c
code = self.client.GetHeaderValue(0)
dataindex = [3, 7, 11, 15, 19, 27, 31, 35, 39, 43]
obi = 0
for i in range(10):
self.rpMst.offer[i] = self.client.GetHeaderValue(dataindex[i])
self.rpMst.bid[i] = self.client.GetHeaderValue(dataindex[i] + 1)
self.rpMst.offervol[i] = self.client.GetHeaderValue(dataindex[i] + 2)
self.rpMst.bidvol[i] = self.client.GetHeaderValue(dataindex[i] + 3)
self.rpMst.totOffer = self.client.GetHeaderValue(23)
self.rpMst.totBid = self.client.GetHeaderValue(24)
# 10차 호가 변경 call back 함수 호출
self.parent.monitorOfferbidChange()
return
# SB/PB 요청 ROOT 클래스
class CpPublish:
def __init__(self, name, serviceID):
self.name = name
self.obj = win32com.client.Dispatch(serviceID)
self.bIsSB = False
def Subscribe(self, var, rpMst, parent):
if self.bIsSB:
self.Unsubscribe()
if (len(var) > 0):
self.obj.SetInputValue(0, var)
handler = win32com.client.WithEvents(self.obj, CpEvent)
handler.set_params(self.obj, self.name, rpMst, parent)
self.obj.Subscribe()
self.bIsSB = True
def Unsubscribe(self):
if self.bIsSB:
self.obj.Unsubscribe()
self.bIsSB = False
# CpPBStockCur: 실시간 현재가 요청 클래스
class CpPBStockCur(CpPublish):
def __init__(self):
super().__init__("stockcur", "DsCbo1.StockCur")
# CpPBStockBid: 실시간 10차 호가 요청 클래스
class CpPBStockBid(CpPublish):
def __init__(self):
super().__init__("stockbid", "Dscbo1.StockJpBid")
# SB/PB 요청 ROOT 클래스
class CpPBConnection:
def __init__(self):
self.obj = win32com.client.Dispatch("CpUtil.CpCybos")
handler = win32com.client.WithEvents(self.obj, CpEvent)
handler.set_params(self.obj, "connection", None)
# CpRPCurrentPrice: 현재가 기본 정보 조회 클래스
class CpRPCurrentPrice:
def __init__(self):
if (g_objCpStatus.IsConnect == 0):
print("PLUS가 정상적으로 연결되지 않음. ")
return
self.objStockMst = win32com.client.Dispatch("DsCbo1.StockMst")
return
def Request(self, code, rtMst, callbackobj):
# 현재가 통신
rtMst.objCur.Unsubscribe()
rtMst.objOfferbid.Unsubscribe()
self.objStockMst.SetInputValue(0, code)
ret = self.objStockMst.BlockRequest()
if self.objStockMst.GetDibStatus() != 0:
print("통신상태", self.objStockMst.GetDibStatus(), self.objStockMst.GetDibMsg1())
return False
# 수신 받은 현재가 정보를 rtMst 에 저장
rtMst.code = code
rtMst.name = g_objCodeMgr.CodeToName(code)
rtMst.cur = self.objStockMst.GetHeaderValue(11) # 종가
rtMst.diff = self.objStockMst.GetHeaderValue(12) # 전일대비
rtMst.baseprice = self.objStockMst.GetHeaderValue(27) # 기준가
rtMst.vol = self.objStockMst.GetHeaderValue(18) # 거래량
rtMst.exFlag = self.objStockMst.GetHeaderValue(58) # 예상플래그
rtMst.expcur = self.objStockMst.GetHeaderValue(55) # 예상체결가
rtMst.expdiff = self.objStockMst.GetHeaderValue(56) # 예상체결대비
rtMst.makediffp()
rtMst.totOffer = self.objStockMst.GetHeaderValue(71) # 총매도잔량
rtMst.totBid = self.objStockMst.GetHeaderValue(73) # 총매수잔량
# 10차호가
for i in range(10):
rtMst.offer[i] = (self.objStockMst.GetDataValue(0, i)) # 매도호가
rtMst.bid[i] = (self.objStockMst.GetDataValue(1, i)) # 매수호가
rtMst.offervol[i] = (self.objStockMst.GetDataValue(2, i)) # 매도호가 잔량
rtMst.bidvol[i] = (self.objStockMst.GetDataValue(3, i)) # 매수호가 잔량
rtMst.objCur.Subscribe(code, rtMst, callbackobj)
rtMst.objOfferbid.Subscribe(code, rtMst, callbackobj)
# CpWeekList: 일자별 리스트 구하기
class CpWeekList:
def __init__(self):
self.objWeek = win32com.client.Dispatch("Dscbo1.StockWeek")
return
def Request(self, code, caller):
# 현재가 통신
self.objWeek.SetInputValue(0, code)
# 데이터들
dates = []
opens = []
highs = []
lows = []
closes = []
diffs = []
vols = []
diffps = []
foreign_vols = []
foreign_diff = []
foreign_p = []
# 누적 개수 - 100 개까지만 하자
sumCnt = 0
while True:
ret = self.objWeek.BlockRequest()
if self.objWeek.GetDibStatus() != 0:
print("통신상태", self.objWeek.GetDibStatus(), self.objWeek.GetDibMsg1())
return False
cnt = self.objWeek.GetHeaderValue(1)
sumCnt += cnt
if cnt == 0:
break
for i in range(cnt):
dates.append(self.objWeek.GetDataValue(0, i))
opens.append(self.objWeek.GetDataValue(1, i))
highs.append(self.objWeek.GetDataValue(2, i))
lows.append(self.objWeek.GetDataValue(3, i))
closes.append(self.objWeek.GetDataValue(4, i))
temp = self.objWeek.GetDataValue(5, i)
diffs.append(temp)
vols.append(self.objWeek.GetDataValue(6, i))
temp2 = self.objWeek.GetDataValue(10, i)
if (temp < 0):
temp2 *= -1
diffps.append(temp2)
foreign_vols.append(self.objWeek.GetDataValue(7, i)) # 외인보유
foreign_diff.append(self.objWeek.GetDataValue(8, i)) # 외인보유 전일대비
foreign_p.append(self.objWeek.GetDataValue(9, i)) # 외인비중
if (sumCnt > 100):
break
if self.objWeek.Continue == False:
break
if len(dates) == 0:
return False
caller.rpWeek = None
weekCol = {'close': closes,
'diff': diffs,
'diffp': diffps,
'vol': vols,
'open': opens,
'high': highs,
'low': lows,
'for_v': foreign_vols,
'for_d': foreign_diff,
'for_p': foreign_p,
}
caller.rpWeek = DataFrame(weekCol, index=dates)
return True
# CpStockBid: 시간대별 조회
class CpStockBid:
def __init__(self):
self.objSBid = win32com.client.Dispatch("Dscbo1.StockBid")
return
def Request(self, code, caller):
# 현재가 통신
self.objSBid.SetInputValue(0, code)
self.objSBid.SetInputValue(2, 80) # 요청개수 (최대 80)
self.objSBid.SetInputValue(3, ord('C')) # C 체결가 비교 방식 H 호가 비교방식
times = []
curs = []
diffs = []
tvols = []
offers = []
bids = []
vols = []
offerbidFlags = [] # 체결 상태 '1' 매수 '2' 매도
volstrs = [] # 체결강도
marketFlags = [] # 장구분 '1' 동시호가 예상체결' '2' 장중
# 누적 개수 - 100 개까지만 하자
sumCnt = 0
while True:
ret = self.objSBid.BlockRequest()
if self.objSBid.GetDibStatus() != 0:
print("통신상태", self.objSBid.GetDibStatus(), self.objSBid.GetDibMsg1())
return False
cnt = self.objSBid.GetHeaderValue(2)
sumCnt += cnt
if cnt == 0:
break
strcur = ""
strflag = ""
strflag2 = ""
for i in range(cnt):
cur = self.objSBid.GetDataValue(4, i)
times.append(self.objSBid.GetDataValue(9, i))
diffs.append(self.objSBid.GetDataValue(1, i))
vols.append(self.objSBid.GetDataValue(5, i))
tvols.append(self.objSBid.GetDataValue(6, i))
offers.append(self.objSBid.GetDataValue(2, i))
bids.append(self.objSBid.GetDataValue(3, i))
flag = self.objSBid.GetDataValue(7, i)
if (flag == ord('1')):
strflag = "체결매수"
else:
strflag = "체결매도"
offerbidFlags.append(strflag)
volstrs.append(self.objSBid.GetDataValue(8, i))
flag = self.objSBid.GetDataValue(10, i)
if (flag == ord('1')):
strflag2 = "예상체결"
# strcur = '*' + str(cur)
else:
strflag2 = "장중"
# strcur = str(cur)
marketFlags.append(strflag2)
curs.append(cur)
if (sumCnt > 100):
break
if self.objSBid.Continue == False:
break
if len(times) == 0:
return False
caller.rpStockBid = None
sBidCol = {'time': times,
'cur': curs,
'diff': diffs,
'vol': vols,
'tvol': tvols,
'offer': offers,
'bid': bids,
'flag': offerbidFlags,
'market': marketFlags,
'volstr': volstrs}
caller.rpStockBid = DataFrame(sBidCol)
print(caller.rpStockBid)
return True
class Form(QtWidgets.QDialog):
def __init__(self, parent=None):
QtWidgets.QDialog.__init__(self, parent)
self.ui = uic.loadUi("hoga.ui", self)
self.ui.show()
self.objMst = CpRPCurrentPrice()
self.item = stockPricedData()
# 일자별
self.objWeek = CpWeekList()
self.rpWeek = DataFrame() # 일자별 데이터프레임
# 시간대별
self.rpStockBid = DataFrame()
self.objStockBid = CpStockBid()
self.todayIndex = 0
self.setCode("000660")
@pyqtSlot()
def slot_codeupdate(self):
code = self.ui.editCode.toPlainText()
self.setCode(code)
def slot_codechanged(self):
code = self.ui.editCode.toPlainText()
self.setCode(code)
def monitorPriceChange(self):
self.displyHoga()
self.updateWeek()
self.updateStockBid()
def monitorOfferbidChange(self):
self.displyHoga()
def setCode(self, code):
if len(code) < 6:
return
print(code)
if not (code[0] == "A"):
code = "A" + code
name = g_objCodeMgr.CodeToName(code)
if len(name) == 0:
print("종목코드 확인")
return
self.ui.label_name.setText(name)
if (self.objMst.Request(code, self.item, self) == False):
return
self.displyHoga()
# 일자별
self.ui.tableWeek.clearContents()
if (self.objWeek.Request(code, self) == True):
print(self.rpWeek)
self.displyWeek()
# 시간대별
self.ui.tableStockBid.clearContents()
if (self.objStockBid.Request(code, self) == True):
self.displyStockBid()
# 10차 호가 UI 채우기
def displyHoga(self):
self.ui.label_offer10.setText(format(self.item.offer[9], ','))
self.ui.label_offer9.setText(format(self.item.offer[8], ','))
self.ui.label_offer8.setText(format(self.item.offer[7], ','))
self.ui.label_offer7.setText(format(self.item.offer[6], ','))
self.ui.label_offer6.setText(format(self.item.offer[5], ','))
self.ui.label_offer5.setText(format(self.item.offer[4], ','))
self.ui.label_offer4.setText(format(self.item.offer[3], ','))
self.ui.label_offer3.setText(format(self.item.offer[2], ','))
self.ui.label_offer2.setText(format(self.item.offer[1], ','))
self.ui.label_offer1.setText(format(self.item.offer[0], ','))
self.ui.label_offer_v10.setText(format(self.item.offervol[9], ','))
self.ui.label_offer_v9.setText(format(self.item.offervol[8], ','))
self.ui.label_offer_v8.setText(format(self.item.offervol[7], ','))
self.ui.label_offer_v7.setText(format(self.item.offervol[6], ','))
self.ui.label_offer_v6.setText(format(self.item.offervol[5], ','))
self.ui.label_offer_v5.setText(format(self.item.offervol[4], ','))
self.ui.label_offer_v4.setText(format(self.item.offervol[3], ','))
self.ui.label_offer_v3.setText(format(self.item.offervol[2], ','))
self.ui.label_offer_v2.setText(format(self.item.offervol[1], ','))
self.ui.label_offer_v1.setText(format(self.item.offervol[0], ','))
self.ui.label_bid10.setText(format(self.item.bid[9], ','))
self.ui.label_bid9.setText(format(self.item.bid[8], ','))
self.ui.label_bid8.setText(format(self.item.bid[7], ','))
self.ui.label_bid7.setText(format(self.item.bid[6], ','))
self.ui.label_bid6.setText(format(self.item.bid[5], ','))
self.ui.label_bid5.setText(format(self.item.bid[4], ','))
self.ui.label_bid4.setText(format(self.item.bid[3], ','))
self.ui.label_bid3.setText(format(self.item.bid[2], ','))
self.ui.label_bid2.setText(format(self.item.bid[1], ','))
self.ui.label_bid1.setText(format(self.item.bid[0], ','))
self.ui.label_bid_v10.setText(format(self.item.bidvol[9], ','))
self.ui.label_bid_v9.setText(format(self.item.bidvol[8], ','))
self.ui.label_bid_v8.setText(format(self.item.bidvol[7], ','))
self.ui.label_bid_v7.setText(format(self.item.bidvol[6], ','))
self.ui.label_bid_v6.setText(format(self.item.bidvol[5], ','))
self.ui.label_bid_v5.setText(format(self.item.bidvol[4], ','))
self.ui.label_bid_v4.setText(format(self.item.bidvol[3], ','))
self.ui.label_bid_v3.setText(format(self.item.bidvol[2], ','))
self.ui.label_bid_v2.setText(format(self.item.bidvol[1], ','))
self.ui.label_bid_v1.setText(format(self.item.bidvol[0], ','))
cur = self.item.cur
diff = self.item.diff
diffp = self.item.diffp
if (self.item.exFlag == ord('1')): # 동시호가 시간 (예상체결)
cur = self.item.expcur
diff = self.item.expdiff
diffp = self.item.expdiffp
strcur = format(cur, ',')
if (self.item.exFlag == ord('1')): # 동시호가 시간 (예상체결)
strcur = "*" + strcur
curcolor = self.item.getCurColor()
self.ui.label_cur.setStyleSheet(curcolor)
self.ui.label_cur.setText(strcur)
strdiff = str(diff) + " " + format(diffp, '.2f')
strdiff += "%"
self.ui.label_diff.setText(strdiff)
self.ui.label_diff.setStyleSheet(curcolor)
self.ui.label_totoffer.setText(format(self.item.totOffer, ','))
self.ui.label_totbid.setText(format(self.item.totBid, ','))
# 일자별 리스트 UI 채우기
def displyWeek(self):
rowcnt = len(self.rpWeek.index)
if rowcnt == 0:
return
self.ui.tableWeek.setRowCount(rowcnt)
nRow = 0
for index, row in self.rpWeek.iterrows():
datas = [index, row['close'], row['diff'], row['diffp'], row['vol'], row['open'], row['high'], row['low'],
row['for_v'], row['for_d'], row['for_p']]
for col in range(len(datas)):
val = ''
if (col == 0): # 일자
# 20170929 ==> 2017/09/29
yyyy = int(datas[col] / 10000)
mm = int(datas[col] - (yyyy * 10000))
dd = mm % 100
mm = mm / 100
val = '%04d/%02d/%02d' % (yyyy, mm, dd)
elif (col == 3 or col == 10): # 대비율
val = locale.format('%.2f', datas[col], 1)
val += "%"
else:
val = locale.format('%d', datas[col], 1)
item = QTableWidgetItem(val)
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.ui.tableWeek.setItem(nRow, col, item)
if (nRow == 0):
self.todayIndex = index
nRow += 1
self.tableWeek.resizeColumnsToContents()
return
# 일자별 리스트 UI 채우기 - 오늘 날짜 업데이트
def updateWeek(self):
rowcnt = len(self.rpWeek.index)
if rowcnt == 0:
return
# 오늘 날짜 데이터 업데이트
self.rpWeek.set_value(self.todayIndex, 'close', self.item.cur)
self.rpWeek.set_value(self.todayIndex, 'open', self.item.open)
self.rpWeek.set_value(self.todayIndex, 'high', self.item.high)
self.rpWeek.set_value(self.todayIndex, 'low', self.item.low)
self.rpWeek.set_value(self.todayIndex, 'vol', self.item.vol)
self.rpWeek.set_value(self.todayIndex, 'diff', self.item.diff)
self.rpWeek.set_value(self.todayIndex, 'diffp', self.item.diffp)
datas = [self.todayIndex, self.item.cur, self.item.diff, self.item.diffp, self.item.vol,
self.item.open, self.item.high, self.item.low]
for col in range(len(datas)):
val = ''
if (col == 0): # 일자
# 20170929 ==> 2017/09/29
yyyy = int(datas[col] / 10000)
mm = int(datas[col] - (yyyy * 10000))
dd = mm % 100
mm = mm / 100
val = '%04d/%02d/%02d' % (yyyy, mm, dd)
elif (col == 3): # 대비율
val = locale.format('%.2f', datas[col], 1)
val += "%"
else:
val = locale.format('%d', datas[col], 1)
item = QTableWidgetItem(val)
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.ui.tableWeek.setItem(0, col, item)
return
# 시간대별 리스트 UI 채우기
def displyStockBid(self):
rowcnt = len(self.rpStockBid.index)
if rowcnt == 0:
return
self.ui.tableStockBid.setRowCount(rowcnt)
nRow = 0
for index, row in self.rpStockBid.iterrows():
# 행 내에 표시할 데이터 - 컬럼 순
datas = [row['time'], row['cur'], row['diff'], row['offer'], row['bid'], row['vol'], row['tvol'],
row['tvol'], row['volstr']]
market = row['market']
for col in range(len(datas)):
val = ''
if col == 0: # 시각
# 155925 ==> 15:59:25
hh = int(datas[col] / 10000)
mm = int(datas[col] - (hh * 10000))
ss = mm % 100
mm = mm / 100
val = '%02d:%02d:%02d' % (hh, mm, ss)
elif col == 6: # 체결매도
market = row['flag']
if (market == "체결매도"):
val = locale.format('%d', datas[col], 1)
elif col == 7: # 체결매수
market = row['flag']
if (market == "체결매수"):
val = locale.format('%d', datas[col], 1)
elif col == 8: # 체결강도
val = locale.format('%.2f', datas[col], 1)
elif col == 1: # 현재가
val = locale.format('%d', datas[col], 1)
if (market == "예상체결"):
val = '*' + val
else: # 기타
val = locale.format('%d', datas[col], 1)
item = QTableWidgetItem(val)
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.ui.tableStockBid.setItem(nRow, col, item)
nRow += 1
self.tableStockBid.resizeColumnsToContents()
return
def updateStockBid(self):
rowcnt = len(self.rpStockBid.index)
if rowcnt == 0:
return
if (self.item.exFlag == ord('1')): # 동시호가 시간 (예상체결)
return
buyvol = sellvol = 0
if self.item.volFlag == ord('1'):
buyvol = self.item.tvol
if self.item.volFlag == ord('2'):
sellvol = self.item.tvol
line = DataFrame({"time": self.item.time,
"cur": self.item.cur,
"diff": self.item.diff,
"offer": self.item.offer[0],
"bid": self.item.bid[0],
"vol": self.item.vol,
"tvol": buyvol,
"tvol": sellvol,
"volstr": self.item.volstr},
index=[0])
self.rpStockBid = pandas.concat([line, self.rpStockBid.ix[:]]).reset_index(drop=True)
# 행 내에 표시할 데이터 - 컬럼 순
datas = [self.item.time, self.item.cur, self.item.diff, self.item.offer[0], self.item.bid[0],
self.item.vol, sellvol, buyvol, self.item.volstr]
self.ui.tableStockBid.insertRow(0)
for col in range(len(datas)):
val = ''
if col == 0: # 시각
# 155925 ==> 15:59:25
hh = int(datas[col] / 10000)
mm = int(datas[col] - (hh * 10000))
ss = mm % 100
mm = mm / 100
val = '%02d:%02d:%02d' % (hh, mm, ss)
elif col == 6: # 체결매도
val = locale.format('%d', datas[col], 1)
elif col == 7: # 체결매수
val = locale.format('%d', datas[col], 1)
elif col == 8: # 체결강도
val = locale.format('%.2f', datas[col], 1)
else: # 기타
val = locale.format('%d', datas[col], 1)
item = QTableWidgetItem(val)
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.ui.tableStockBid.setItem(0, col, item)
return
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
w = Form()
sys.exit(app.exec())