hikyuu 2.6.5__py3-none-win_amd64.whl → 2.6.7__py3-none-win_amd64.whl

hikyuu/fetcher/stock/zh_stock_a_pytdx.py

@@ -41,26 +41,15 @@ def parse_one_result(quotes):
     else:
         result['volume'] = float(quotes['vol'])  # 成交的股票手数
     result['amount'] = round(quotes['amount'] * 0.0001, 2)  # 成交金额，单位为“元”，若要以“万元”为成交金额的单位，需要把该值除以一万
-    result['bid1_amount'] = float(quotes['bid_vol1'])  # “买一”申请4695股，即47手
-    result['bid1'] = float(quotes['bid1'])  # “买一”报价
-    result['bid2_amount'] = float(quotes['bid_vol2'])
-    result['bid2'] = float(quotes['bid2'])
-    result['bid3_amount'] = float(quotes['bid_vol3'])
-    result['bid3'] = float(quotes['bid3'])
-    result['bid4_amount'] = float(quotes['bid_vol4'])
-    result['bid4'] = float(quotes['bid4'])
-    result['bid5_amount'] = float(quotes['bid_vol5'])
-    result['bid5'] = float(quotes['bid5'])
-    result['ask1_amount'] = float(quotes['ask_vol1'])  # “卖一”申报3100股，即31手
-    result['ask1'] = float(quotes['ask1'])  # “卖一”报价
-    result['ask2_amount'] = float(quotes['ask_vol2'])
-    result['ask2'] = float(quotes['ask2'])
-    result['ask3_amount'] = float(quotes['ask_vol3'])
-    result['ask3'] = float(quotes['ask3'])
-    result['ask4_amount'] = float(quotes['ask_vol4'])
-    result['ask4'] = float(quotes['ask4'])
-    result['ask5_amount'] = float(quotes['ask_vol5'])
-    result['ask5'] = float(quotes['ask5'])
+
+    result['bid'] = [float(quotes['bid1']), float(quotes['bid2']), float(
+        quotes['bid3']), float(quotes['bid4']), float(quotes['bid5'])]
+    result['bid_amount'] = [float(quotes['bid_vol1']), float(quotes['bid_vol2']), float(
+        quotes['bid_vol3']), float(quotes['bid_vol4']), float(quotes['bid_vol5'])]
+    result['ask'] = [float(quotes['ask1']), float(quotes['ask2']), float(
+        quotes['ask3']), float(quotes['ask4']), float(quotes['ask5'])]
+    result['ask_amount'] = [float(quotes['ask_vol1']), float(quotes['ask_vol2']), float(
+        quotes['ask_vol3']), float(quotes['ask_vol4']), float(quotes['ask_vol5'])]
     return result
 
 

hikyuu/fetcher/stock/zh_stock_a_qmt.py

@@ -33,11 +33,10 @@ try:
         result['amount'] = data['amount'] * 0.0001  # 转千元
         result['volume'] = data['pvolume'] * 0.01  # 转手数
 
-        for i in range(5):
-            result[f'bid{i+1}'] = data['bidPrice'][i]
-            result[f'bid{i+1}_amount'] = data['bidVol'][i]
-            result[f'ask{i+1}'] = data['askPrice'][i]
-            result[f'ask{i+1}_amount'] = data['askVol'][i]
+        result['bid'] = data['bidPrice']
+        result['bid_amount'] = data['bidVol']
+        result['ask'] = data['askPrice']
+        result['ask_amount'] = data['askVol']
         return result
 
     def get_spot(stocklist, unused1=None, unused2=None, batch_func=None):

hikyuu/fetcher/stock/zh_stock_a_sina_qq.py

@@ -80,26 +80,21 @@ def parse_one_result_qq(resultstr):
     # result['amount'] = float(a[6])  # 成交量
     # 7: 外盘 ？
     # 8：内盘 ？
-    result['bid1'] = float(a[9])  # “买一”报价
-    result['bid1_amount'] = float(a[10])  # “买一”申请4695股，即47手
-    result['bid2'] = float(a[11])
-    result['bid2_amount'] = float(a[12])
-    result['bid3'] = float(a[13])
-    result['bid3_amount'] = float(a[14])
-    result['bid4'] = float(a[15])
-    result['bid4_amount'] = float(a[16])
-    result['bid5'] = float(a[17])
-    result['bid5_amount'] = float(a[18])
-    result['ask1'] = float(a[19])  # “卖一”报价
-    result['ask1_amount'] = float(a[20])  # “卖一”申报3100股，即31手
-    result['ask2'] = float(a[21])
-    result['ask2_amount'] = float(a[22])
-    result['ask3'] = float(a[23])
-    result['ask3_amount'] = float(a[24])
-    result['ask4'] = float(a[25])
-    result['ask4_amount'] = float(a[26])
-    result['ask5'] = float(a[27])
-    result['ask5_amount'] = float(a[28])
+    bid = []
+    bid_amount = []
+    for i in range(9, 18, 2):
+        bid.append(float(a[i]))
+        bid_amount.append(float(a[i + 1]))
+    result['bid'] = bid
+    result['bid_amount'] = bid_amount
+    ask = []
+    ask_amount = []
+    for i in range(19, 28, 2):
+        ask.append(float(a[i]))
+        ask_amount.append(float(a[i + 1]))
+    result['ask'] = ask
+    result['ask_amount'] = ask_amount
+
     # result['最近逐笔成交'] = float(a[29])
     x = a[30]
     result['datetime'] = datetime.datetime(
@@ -139,46 +134,6 @@ def request_data(querystr, parse_one_result, use_proxy=False):
     return result
 
 
-def get_spotV1(stocklist, source='qq', use_proxy=False, batch_func=None):
-    """获取实时数据，获取失败时，抛出异常
-
-    :param list stocklist: 股票名称列表，股票名称示例：sh000001, sz000001
-    :param str source: 使用 sina 还是 qq 作为数据来源
-    :param boolean: use_proxy: 是否使用代理
-    :param function batch_func: 当网络请求返回一个批次数据时，调用该函数，通常用于向数据库写入数据
-    """
-    if source == 'sina':
-        queryStr = "http://hq.sinajs.cn/list="
-        max_size = 140
-        parse_one_result = parse_one_result_sina
-        hku_error("新浪接口已不再支持！")
-    else:
-        queryStr = "http://qt.gtimg.cn/q="
-        max_size = 60
-        parse_one_result = parse_one_result_qq
-    count = 0
-    tmpstr = queryStr
-    result = []
-    for stock in stocklist:
-        tmpstr += ("%s,") % (stock)
-        count += 1
-        if count >= max_size:
-            phase_result = request_data(tmpstr, parse_one_result, use_proxy)
-            if phase_result:
-                result.extend(phase_result)
-                if batch_func:
-                    batch_func(phase_result)
-            count = 0
-            tmpstr = queryStr
-    if tmpstr != queryStr:
-        phase_result = request_data(tmpstr, parse_one_result, use_proxy)
-        if phase_result:
-            result.extend(phase_result)
-            if batch_func:
-                batch_func(phase_result)
-    return result
-
-
 def get_spot(stocklist, source='sina', use_proxy=False, batch_func=None):
     """并发网络请求获取实时数据，获取失败时，抛出异常
 
@@ -188,6 +143,7 @@ def get_spot(stocklist, source='sina', use_proxy=False, batch_func=None):
     :param function batch_func: 当网络请求返回一个批次数据时，调用该函数，通常用于向数据库写入数据
     """
     if source == 'sina':
+        raise Exception("新浪数据源已不支持")
         queryStr = "http://hq.sinajs.cn/list="
         max_size = 140
         parse_one_result = parse_one_result_sina

hikyuu/flat/Spot.py

@@ -102,147 +102,115 @@ class Spot(object):
         return 0.0
 
     # Spot
-    def Bid1(self):
+    def Bid(self, j):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
-
-    # Spot
-    def Bid1Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
-
-    # Spot
-    def Bid2(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
-
-    # Spot
-    def Bid2Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
-
-    # Spot
-    def Bid3(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
 
     # Spot
-    def Bid3Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+    def BidAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
 
     # Spot
-    def Bid4(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+    def BidLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.VectorLen(o)
+        return 0
 
     # Spot
-    def Bid4Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+    def BidIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
 
     # Spot
-    def Bid5(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+    def BidAmount(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
 
     # Spot
-    def Bid5Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
+    def BidAmountAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
 
     # Spot
-    def Ask1(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
+    def BidAmountLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.VectorLen(o)
+        return 0
 
     # Spot
-    def Ask1Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+    def BidAmountIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        return o == 0
 
     # Spot
-    def Ask2(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
+    def Ask(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
 
     # Spot
-    def Ask2Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
+    def AskAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
 
     # Spot
-    def Ask3(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
+    def AskLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.VectorLen(o)
+        return 0
 
     # Spot
-    def Ask3Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+    def AskIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
 
     # Spot
-    def Ask4(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
+    def AskAmount(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
 
     # Spot
-    def Ask4Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
+    def AskAmountAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
+        return 0
 
     # Spot
-    def Ask5(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
+    def AskAmountLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
         if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+            return self._tab.VectorLen(o)
+        return 0
 
     # Spot
-    def Ask5Amount(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
-        if o != 0:
-            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
-        return 0.0
+    def AskAmountIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
 
 def SpotStart(builder):
-    builder.StartObject(31)
+    builder.StartObject(15)
 
 def Start(builder):
     SpotStart(builder)
@@ -313,125 +281,53 @@ def SpotAddVolume(builder, volume):
 def AddVolume(builder, volume):
     SpotAddVolume(builder, volume)
 
-def SpotAddBid1(builder, bid1):
-    builder.PrependFloat64Slot(11, bid1, 0.0)
-
-def AddBid1(builder, bid1):
-    SpotAddBid1(builder, bid1)
-
-def SpotAddBid1Amount(builder, bid1Amount):
-    builder.PrependFloat64Slot(12, bid1Amount, 0.0)
-
-def AddBid1Amount(builder, bid1Amount):
-    SpotAddBid1Amount(builder, bid1Amount)
-
-def SpotAddBid2(builder, bid2):
-    builder.PrependFloat64Slot(13, bid2, 0.0)
-
-def AddBid2(builder, bid2):
-    SpotAddBid2(builder, bid2)
-
-def SpotAddBid2Amount(builder, bid2Amount):
-    builder.PrependFloat64Slot(14, bid2Amount, 0.0)
-
-def AddBid2Amount(builder, bid2Amount):
-    SpotAddBid2Amount(builder, bid2Amount)
-
-def SpotAddBid3(builder, bid3):
-    builder.PrependFloat64Slot(15, bid3, 0.0)
-
-def AddBid3(builder, bid3):
-    SpotAddBid3(builder, bid3)
-
-def SpotAddBid3Amount(builder, bid3Amount):
-    builder.PrependFloat64Slot(16, bid3Amount, 0.0)
-
-def AddBid3Amount(builder, bid3Amount):
-    SpotAddBid3Amount(builder, bid3Amount)
-
-def SpotAddBid4(builder, bid4):
-    builder.PrependFloat64Slot(17, bid4, 0.0)
-
-def AddBid4(builder, bid4):
-    SpotAddBid4(builder, bid4)
-
-def SpotAddBid4Amount(builder, bid4Amount):
-    builder.PrependFloat64Slot(18, bid4Amount, 0.0)
-
-def AddBid4Amount(builder, bid4Amount):
-    SpotAddBid4Amount(builder, bid4Amount)
-
-def SpotAddBid5(builder, bid5):
-    builder.PrependFloat64Slot(19, bid5, 0.0)
-
-def AddBid5(builder, bid5):
-    SpotAddBid5(builder, bid5)
-
-def SpotAddBid5Amount(builder, bid5Amount):
-    builder.PrependFloat64Slot(20, bid5Amount, 0.0)
-
-def AddBid5Amount(builder, bid5Amount):
-    SpotAddBid5Amount(builder, bid5Amount)
-
-def SpotAddAsk1(builder, ask1):
-    builder.PrependFloat64Slot(21, ask1, 0.0)
-
-def AddAsk1(builder, ask1):
-    SpotAddAsk1(builder, ask1)
-
-def SpotAddAsk1Amount(builder, ask1Amount):
-    builder.PrependFloat64Slot(22, ask1Amount, 0.0)
-
-def AddAsk1Amount(builder, ask1Amount):
-    SpotAddAsk1Amount(builder, ask1Amount)
-
-def SpotAddAsk2(builder, ask2):
-    builder.PrependFloat64Slot(23, ask2, 0.0)
+def SpotAddBid(builder, bid):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(bid), 0)
 
-def AddAsk2(builder, ask2):
-    SpotAddAsk2(builder, ask2)
+def AddBid(builder, bid):
+    SpotAddBid(builder, bid)
 
-def SpotAddAsk2Amount(builder, ask2Amount):
-    builder.PrependFloat64Slot(24, ask2Amount, 0.0)
+def SpotStartBidVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
 
-def AddAsk2Amount(builder, ask2Amount):
-    SpotAddAsk2Amount(builder, ask2Amount)
+def StartBidVector(builder, numElems):
+    return SpotStartBidVector(builder, numElems)
 
-def SpotAddAsk3(builder, ask3):
-    builder.PrependFloat64Slot(25, ask3, 0.0)
+def SpotAddBidAmount(builder, bidAmount):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(bidAmount), 0)
 
-def AddAsk3(builder, ask3):
-    SpotAddAsk3(builder, ask3)
+def AddBidAmount(builder, bidAmount):
+    SpotAddBidAmount(builder, bidAmount)
 
-def SpotAddAsk3Amount(builder, ask3Amount):
-    builder.PrependFloat64Slot(26, ask3Amount, 0.0)
+def SpotStartBidAmountVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
 
-def AddAsk3Amount(builder, ask3Amount):
-    SpotAddAsk3Amount(builder, ask3Amount)
+def StartBidAmountVector(builder, numElems):
+    return SpotStartBidAmountVector(builder, numElems)
 
-def SpotAddAsk4(builder, ask4):
-    builder.PrependFloat64Slot(27, ask4, 0.0)
+def SpotAddAsk(builder, ask):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(ask), 0)
 
-def AddAsk4(builder, ask4):
-    SpotAddAsk4(builder, ask4)
+def AddAsk(builder, ask):
+    SpotAddAsk(builder, ask)
 
-def SpotAddAsk4Amount(builder, ask4Amount):
-    builder.PrependFloat64Slot(28, ask4Amount, 0.0)
+def SpotStartAskVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
 
-def AddAsk4Amount(builder, ask4Amount):
-    SpotAddAsk4Amount(builder, ask4Amount)
+def StartAskVector(builder, numElems):
+    return SpotStartAskVector(builder, numElems)
 
-def SpotAddAsk5(builder, ask5):
-    builder.PrependFloat64Slot(29, ask5, 0.0)
+def SpotAddAskAmount(builder, askAmount):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(askAmount), 0)
 
-def AddAsk5(builder, ask5):
-    SpotAddAsk5(builder, ask5)
+def AddAskAmount(builder, askAmount):
+    SpotAddAskAmount(builder, askAmount)
 
-def SpotAddAsk5Amount(builder, ask5Amount):
-    builder.PrependFloat64Slot(30, ask5Amount, 0.0)
+def SpotStartAskAmountVector(builder, numElems):
+    return builder.StartVector(8, numElems, 8)
 
-def AddAsk5Amount(builder, ask5Amount):
-    SpotAddAsk5Amount(builder, ask5Amount)
+def StartAskAmountVector(builder, numElems):
+    return SpotStartAskAmountVector(builder, numElems)
 
 def SpotEnd(builder):
     return builder.EndObject()