hikyuu 2.6.8__py3-none-manylinux2014_aarch64.whl

hikyuu/test/Environment.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+#===============================================================================
+# 作者：fasiondog
+# 历史：1）20130311, Added by fasiondog
+#===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class EnvironmentPython(EnvironmentBase):
+    def __init__(self):
+        super(EnvironmentPython, self).__init__("EnvironmentPython")
+        self.set_param("n", 10)
+        self._m_flag = False
+
+    def is_valid(self, market, datetime):
+        return self._m_flag
+
+    def _reset(self):
+        if self._m_flag:
+            self._m_flag = False
+        else:
+            self._m_flag = True
+
+    def _clone(self):
+        p = EnvironmentPython()
+        p._m_flag = self._m_flag
+        return p
+
+
+class EnvironmentTest(unittest.TestCase):
+    def test_EnvironmentBase(self):
+        p = EnvironmentPython()
+        self.assertEqual(p.name, "EnvironmentPython")
+        self.assertEqual(p.get_param("n"), 10)
+        p.set_param("n", 20)
+        self.assertEqual(p.get_param("n"), 20)
+        self.assertEqual(p.is_valid("SH", Datetime(200101010000)), False)
+        p.reset()
+        self.assertEqual(p.is_valid("SH", Datetime(200101010000)), True)
+
+        p_clone = p.clone()
+        self.assertEqual(p_clone.name, "EnvironmentPython")
+        self.assertEqual(p_clone.get_param("n"), 20)
+        self.assertEqual(p_clone.is_valid("SH", Datetime(200101010000)), True)
+
+        p.set_param("n", 1)
+        p_clone.set_param("n", 3)
+        self.assertEqual(p.get_param("n"), 1)
+        self.assertEqual(p_clone.get_param("n"), 3)
+
+
+def test_crtEV_func(self):
+    self._add_valid(Datetime(200101010000))
+
+
+class TestCrtEV(unittest.TestCase):
+    def test_crtEV(self):
+        p = crtEV(test_crtEV_func, params={'n': 10}, name='EnvironmentPython')
+        self.assertEqual(p.name, "EnvironmentPython")
+        self.assertEqual(p.get_param("n"), 10)
+        p.set_param("n", 20)
+        self.assertEqual(p.get_param("n"), 20)
+        p.query = Query(-100)  #ev在设置查询对象时才会调用_caculate函数
+        self.assertEqual(p.is_valid(Datetime(200101010000)), True)
+
+        p_clone = p.clone()
+        self.assertEqual(p_clone.name, "EnvironmentPython")
+        self.assertEqual(p_clone.get_param("n"), 20)
+        self.assertEqual(p_clone.is_valid(Datetime(200101010000)), True)
+
+        p.set_param("n", 1)
+        p_clone.set_param("n", 3)
+        self.assertEqual(p.get_param("n"), 1)
+        self.assertEqual(p_clone.get_param("n"), 3)
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(EnvironmentTest)
+
+
+def suiteTestCrtEV():
+    return unittest.TestLoader().loadTestsFromTestCase(TestCrtEV)

hikyuu/test/Indicator.py

@@ -0,0 +1,233 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+# ===============================================================================
+# 作者：fasiondog
+# 历史：1）20130220, Added by fasiondog
+# ===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class AddIndicator(IndicatorImp):
+    def __init__(self, indicator):
+        super(AddIndicator, self).__init__("AddIndicator")
+        self._ready_buffer(len(indicator), 1)
+        self.set_discard(0)
+        for i in range(len(indicator)):
+            self._set(indicator[i] + 1, i)
+
+    def _clone(self):
+        return AddIndicator(Indicator())
+
+    def _calculate(self, ind):
+        self.set_discard(0)
+        for i in range(len(ind)):
+            self._set(ind[i] + 1, i)
+
+
+class IndicatorTest(unittest.TestCase):
+    def test_PRICELIST(self):
+        a = toPriceList([0, 1, 2, 3])
+        x = PRICELIST(a)
+        self.assertEqual(len(x), 4)
+        self.assertEqual(x.empty(), False)
+        self.assertEqual(x.discard, 0)
+        self.assertEqual(x[0], 0)
+        self.assertEqual(x[1], 1)
+        self.assertEqual(x[2], 2)
+        self.assertEqual(x[3], 3)
+
+    def test_PythonIndicator(self):
+        a = toPriceList([0, 1, 2, 3])
+        x = PRICELIST(a)
+        m = Indicator(AddIndicator(x))
+        self.assertEqual(m.name, "AddIndicator")
+        self.assertEqual(len(m), 4)
+        self.assertEqual(m.empty(), False)
+        self.assertTrue(abs(m[0] - 1) < 0.0001)
+        self.assertTrue(abs(m[1] - 2) < 0.0001)
+        self.assertTrue(abs(m[2] - 3) < 0.0001)
+        self.assertTrue(abs(m[3] - 4) < 0.0001)
+
+        b = toPriceList([1, 2, 3, 4])
+        x = PRICELIST(b)
+        m.get_imp()._calculate(m)
+        m = m(x)
+        self.assertEqual(len(m), 4)
+        self.assertEqual(m.empty(), False)
+        self.assertTrue(abs(m[0] - 2) < 0.0001)
+        self.assertTrue(abs(m[1] - 3) < 0.0001)
+        self.assertTrue(abs(m[2] - 4) < 0.0001)
+        self.assertTrue(abs(m[3] - 5) < 0.0001)
+
+    def test_operator(self):
+        a = toPriceList([0, 1, 2, 3, 5])
+        x1 = PRICELIST(a)
+        a = toPriceList([1, 2, 3, 4, 5])
+        x2 = PRICELIST(a)
+        a = x1 + x2
+        self.assertEqual(a[0], 1)
+        self.assertEqual(a[1], 3)
+        self.assertEqual(a[2], 5)
+        self.assertEqual(a[3], 7)
+
+        a = x1 + 1.1
+        self.assertTrue(abs(a[0] - 1.1) < 0.0001)
+        self.assertTrue(abs(a[1] - 2.1) < 0.0001)
+        self.assertTrue(abs(a[2] - 3.1) < 0.0001)
+        self.assertTrue(abs(a[3] - 4.1) < 0.0001)
+
+        a = 2.1 + x1
+        self.assertTrue(abs(a[0] - 2.1) < 0.0001)
+        self.assertTrue(abs(a[1] - 3.1) < 0.0001)
+        self.assertTrue(abs(a[2] - 4.1) < 0.0001)
+        self.assertTrue(abs(a[3] - 5.1) < 0.0001)
+
+        a = x2 - x1
+        self.assertEqual(a[0], 1)
+        self.assertEqual(a[1], 1)
+        self.assertEqual(a[2], 1)
+        self.assertEqual(a[3], 1)
+
+        a = x1 - 1.5
+        self.assertEqual(a[0], -1.5)
+        self.assertEqual(a[1], -0.5)
+        self.assertEqual(a[2], 0.5)
+        self.assertEqual(a[3], 1.5)
+
+        a = 1.5 - x1
+        self.assertEqual(a[0], 1.5)
+        self.assertEqual(a[1], 0.5)
+        self.assertEqual(a[2], -0.5)
+        self.assertEqual(a[3], -1.5)
+
+        a = x1 * x2
+        self.assertEqual(a[0], 0)
+        self.assertEqual(a[1], 2)
+        self.assertEqual(a[2], 6)
+        self.assertEqual(a[3], 12)
+
+        a = x1 * 2.0
+        self.assertEqual(a[0], 0)
+        self.assertEqual(a[1], 2)
+        self.assertEqual(a[2], 4)
+        self.assertEqual(a[3], 6)
+
+        a = 2.0 * x1
+        self.assertEqual(a[0], 0)
+        self.assertEqual(a[1], 2)
+        self.assertEqual(a[2], 4)
+        self.assertEqual(a[3], 6)
+
+        a = x2 / x1
+        self.assertTrue(isinf(a[0]))
+        self.assertEqual(a[1], 2)
+        self.assertEqual(a[2], 1.5)
+        self.assertTrue(abs(a[3] - 4.0 / 3.0) < 0.0001)
+
+        a = x1 / 0.5
+        self.assertEqual(a[0], 0)
+        self.assertEqual(a[1], 2)
+        self.assertEqual(a[2], 4)
+        self.assertEqual(a[3], 6)
+
+        a = 2. / x1
+        self.assertTrue(isinf(a[0]))
+        self.assertEqual(a[1], 2.0)
+        self.assertEqual(a[2], 1.)
+        self.assertTrue(abs(a[3] - 2.0/3.0) < 0.0001)
+
+        a = x1 > x2
+        self.assertEqual(a[0], 0 > 1)
+        self.assertEqual(a[1], 1 > 2)
+        self.assertEqual(a[2], 2 > 3)
+        self.assertEqual(a[3], 3 > 4)
+        self.assertEqual(a[4], 5 > 5)
+
+        a = x2 > x1
+        self.assertEqual(a[0], 0 < 1)
+        self.assertEqual(a[1], 1 < 2)
+        self.assertEqual(a[2], 2 < 3)
+        self.assertEqual(a[3], 3 < 4)
+        self.assertEqual(a[4], 5 < 5)
+
+    def test_IKDATA(self):
+        s = sm['sh000001']
+        q = Query(0, 10)
+        k = s.get_kdata(q)
+        o = OPEN(k)
+        h = HIGH(k)
+        l = LOW(k)
+        c = CLOSE(k)
+        a = AMO(k)
+        v = VOL(k)
+
+        self.assertEqual(len(o), 10)
+        self.assertEqual(len(h), 10)
+        self.assertEqual(len(l), 10)
+        self.assertEqual(len(c), 10)
+        self.assertEqual(len(a), 10)
+        self.assertEqual(len(v), 10)
+
+        self.assertEqual(o.empty(), False)
+        self.assertEqual(h.empty(), False)
+        self.assertEqual(l.empty(), False)
+        self.assertEqual(c.empty(), False)
+        self.assertEqual(a.empty(), False)
+        self.assertEqual(v.empty(), False)
+
+        self.assertTrue(abs(o[0] - 96.05) < 0.0001)
+        self.assertTrue(abs(h[0] - 99.98) < 0.0001)
+        self.assertTrue(abs(l[0] - 95.79) < 0.0001)
+        self.assertTrue(abs(c[0] - 99.98) < 0.0001)
+        self.assertTrue(abs(a[0] - 49.4) < 0.0001)
+        self.assertTrue(abs(v[0] - 1260) < 0.0001)
+
+        self.assertTrue(abs(o[1] - 104.3) < 0.0001)
+        self.assertTrue(abs(h[1] - 104.39) < 0.0001)
+        self.assertTrue(abs(l[1] - 99.98) < 0.0001)
+        self.assertTrue(abs(c[1] - 104.39) < 0.0001)
+        self.assertTrue(abs(a[1] - 8.4) < 0.0001)
+        self.assertTrue(abs(v[1] - 197) < 0.0001)
+
+    def test_MA(self):
+        a = toPriceList([0, 1, 2, 3])
+        x = PRICELIST(a)
+        m = MA(x, 2)
+        self.assertEqual(len(m), 4)
+        self.assertEqual(m.discard, 0)
+        self.assertTrue(abs(m[0] - 0.0) < 0.0001)
+        self.assertTrue(abs(m[1] - 0.5) < 0.0001)
+        self.assertTrue(abs(m[2] - 1.5) < 0.0001)
+        self.assertTrue(abs(m[3] - 2.5) < 0.0001)
+
+    def test_pickle(self):
+        if not constant.pickle_support:
+            return
+
+        # TODO Python3出错，暂未解决
+        """
+        import pickle as pl
+        filename = sm.tmpdir() + '/Indicator.plk'
+        stock = sm['sh000001']
+        kdata = stock.getKData(Query(0,10))
+        a = CLOSE(kdata)
+        fh = open(filename, 'wb')
+        pl.dump(a, fh)
+        fh.close()
+        fh = open(filename, 'rb')
+        b = pl.load(fh)
+        fh.close()
+        self.assertEqual(a.size(), b.size())
+        self.assertNotEqual(a.size(), 0)
+        for i in range(len(a)):
+            self.assertEqual(a[i], b[i])
+        """
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(IndicatorTest)

hikyuu/test/KData.py

@@ -0,0 +1,64 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+# ===============================================================================
+# 作者：fasiondog
+# 历史：1）20130220, Added by fasiondog
+# ===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class KDataTest(unittest.TestCase):
+    def test_null_kdata(self):
+        k = KData()
+        self.assertEqual(len(k), 0)
+        self.assertEqual(k.empty(), True)
+        self.assertEqual(k.start_pos, 0)
+        self.assertEqual(k.end_pos, 0)
+        self.assertEqual(k.last_pos, 0)
+        stock = k.get_stock()
+        self.assertEqual(stock.is_null(), True)
+
+    def test_kdata(self):
+        stock = sm["Sh000001"]
+        q = Query(0, 10)
+        k = stock.get_kdata(q)
+        self.assertEqual(len(k), 10)
+        self.assertEqual(k.empty(), False)
+        self.assertEqual(k.start_pos, 0)
+        self.assertEqual(k.end_pos, 10)
+        self.assertEqual(k.last_pos, 9)
+        self.assertEqual(k[0].datetime, Datetime(199012190000))
+        self.assertTrue(abs(k[0].open - 96.05) < 0.0001)
+        self.assertTrue(abs(k[0].high - 99.980) < 0.0001)
+        self.assertTrue(abs(k[0].low - 95.79) < 0.0001)
+        self.assertTrue(abs(k[0].close - 99.98) < 0.0001)
+        self.assertTrue(abs(k[0].amount - 49.4) < 0.0001)
+        self.assertTrue(abs(k[0].volume - 1260) < 0.0001)
+        self.assertTrue(abs(k[1].open - 104.3) < 0.0001)
+        self.assertTrue(abs(k[9].open - 127.61) < 0.0001)
+
+    def test_pickle(self):
+        if not constant.pickle_support:
+            return
+
+        import pickle as pl
+        filename = sm.tmpdir() + "/KData.plk"
+        fh = open(filename, 'wb')
+        kdata = sm['sh000001'].get_kdata(Query(10, 20))
+        pl.dump(kdata, fh)
+        fh.close()
+        fh = open(filename, 'rb')
+        b = pl.load(fh)
+        fh.close()
+        self.assertEqual(len(kdata), len(b))
+        for i in range(len(kdata)):
+            self.assertEqual(kdata[i], b[i])
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(KDataTest)

hikyuu/test/MarketInfo.py

@@ -0,0 +1,26 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+#===============================================================================
+# 作者：fasiondog
+# 历史：1）20120927, Added by fasiondog
+#===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class MarketInfoTest(unittest.TestCase):
+    def test_market(self):
+        market = sm.get_market_info("Sh")
+        self.assertEqual(market.market, "SH")
+        self.assertEqual(market.name, u"上海证券交易所")
+        self.assertEqual(market.description, u"上海市场")
+        self.assertEqual(market.code, "000001")
+        self.assertEqual(market.last_datetime, Datetime(201112060000))
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MarketInfoTest)

hikyuu/test/MoneyManager.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+# ===============================================================================
+# 作者：fasiondog
+# 历史：1）20130316, Added by fasiondog
+# ===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class MoneyManagerPython(MoneyManagerBase):
+    def __init__(self):
+        super(MoneyManagerPython, self).__init__("MoneyManagerPython")
+        self.set_param("n", 10)
+        self._m_flag = False
+
+    def get_buy_num(self, datetime, stock, price, risk):
+        if self._m_flag:
+            return 10
+        else:
+            return 20
+
+    def _reset(self):
+        if self._m_flag:
+            self._m_flag = False
+        else:
+            self._m_flag = True
+
+    def _clone(self):
+        p = MoneyManagerPython()
+        p._m_flag = self._m_flag
+        return p
+
+
+class MoneyManagerTest(unittest.TestCase):
+    def test_ConditionBase(self):
+        stock = sm['sh000001']
+        p = MoneyManagerPython()
+        self.assertEqual(p.name, "MoneyManagerPython")
+        self.assertEqual(p.get_param("n"), 10)
+        p.set_param("n", 20)
+        self.assertEqual(p.get_param("n"), 20)
+        self.assertEqual(p.get_buy_num(Datetime(200101010000), stock, 10.0, 0.0), 20)
+        p.reset()
+        self.assertEqual(p.get_buy_num(Datetime(200101010000), stock, 10.0, 0.0), 10)
+
+        p_clone = p.clone()
+        self.assertEqual(p_clone.name, "MoneyManagerPython")
+        self.assertEqual(p_clone.get_param("n"), 20)
+        self.assertEqual(p_clone.get_buy_num(Datetime(200101010000), stock, 10, 0.0), 10)
+
+        p.set_param("n", 1)
+        p_clone.set_param("n", 3)
+        self.assertEqual(p.get_param("n"), 1)
+        self.assertEqual(p_clone.get_param("n"), 3)
+
+
+def testCrtMM(self):
+    pass
+
+
+def testget_buy_num(self, datetime, stock, price, risk, part):
+    return 10.0 if datetime == Datetime(200101010000) else 0.0
+
+
+class TestCrtMM(unittest.TestCase):
+    def test_crt_mm(self):
+        p = crtMM(testget_buy_num, testCrtMM, params={'n': 10}, name="TestMM")
+        p.tm = crtTM(Datetime(200101010000))
+        self.assertEqual(p.name, "TestMM")
+        stock = sm['sh000001']
+        self.assertEqual(p.get_buy_num(Datetime(200101010000), stock, 1.0, 1.0, SystemPart.MM), 10.0)
+        self.assertEqual(p.get_buy_num(Datetime(200101020000), stock, 1.0, 1.0, SystemPart.MM), 0.0)
+
+        p_clone = p.clone()
+        self.assertEqual(p_clone.name, "TestMM")
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MoneyManagerTest)
+
+
+def suiteTestCrtMM():
+    return unittest.TestLoader().loadTestsFromTestCase(TestCrtMM)

hikyuu/test/Parameter.py

@@ -0,0 +1,62 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+#===============================================================================
+# 作者：fasiondog
+# 历史：1）20130220, Added by fasiondog
+#===============================================================================
+
+from test_init import *
+import unittest
+from hikyuu import Parameter
+
+
+class ParameterTest(unittest.TestCase):
+    def test_Parameter(self):
+        p = Parameter()
+        self.assertEqual("n" in p, False)
+        self.assertEqual("b" in p, False)
+        self.assertEqual("d" in p, False)
+        self.assertEqual("s" in p, False)
+        p["n"] = 10
+        p["b"] = True
+        p["d"] = 10.01
+        p["s"] = "string"
+        self.assertEqual("n" in p, True)
+        self.assertEqual("b" in p, True)
+        self.assertEqual("d" in p, True)
+        self.assertEqual("s" in p, True)
+        self.assertEqual(p["n"], 10)
+        self.assertEqual(p["b"], True)
+        self.assertEqual(p["d"], 10.01)
+        self.assertEqual(p["s"], "string")
+
+        p["n"] = 20
+        p["b"] = False
+        p["d"] = 10.001
+        p["s"] = "string2"
+        self.assertEqual(p["n"], 20)
+        self.assertEqual(p["b"], False)
+        self.assertEqual(p["d"], 10.001)
+        self.assertEqual(p["s"], "string2")
+
+    # def test_pickle(self):
+    #     if not constant.pickle_support:
+    #         return
+    #     tmpdir = sm.tmpdir()
+    #     fh = open(tmpdir + "/Parameter.plk", "wb")
+    #     a = Parameter()
+    #     a["bool"] = True
+    #     a["string"] = "This is Parameter"
+    #     import pickle as pl
+    #     pl.dump(a, fh)
+    #     fh.close()
+    #     fh = open(tmpdir + "/Parameter.plk", "rb")
+    #     b = pl.load(fh)
+    #     self.assertEqual(b["bool"], True)
+    #     self.assertEqual(b["string"], "This is Parameter")
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(ParameterTest)

hikyuu/test/ProfitGoal.py

@@ -0,0 +1,83 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# gb18030
+
+#===============================================================================
+# 作者：fasiondog
+# 历史：1）20130321, Added by fasiondog
+#===============================================================================
+
+import unittest
+
+from test_init import *
+
+
+class ProfitGoalPython(ProfitGoalBase):
+    def __init__(self):
+        super(ProfitGoalPython, self).__init__("ProfitGoalPython")
+        self._x = 0
+
+    def getGoal(self, datetime, price):
+        if self._x < 10:
+            return 0.0
+        return 1.0
+
+    def _reset(self):
+        self._x = 0
+
+    def _clone(self):
+        p = ProfitGoalPython()
+        p._x = self._x
+        return p
+
+    def _calculate(self):
+        """ do nothing """
+
+
+class ProfitGoalTest(unittest.TestCase):
+    def test_ProfitGoalBase(self):
+        p = ProfitGoalPython()
+        self.assertEqual(p.name, "ProfitGoalPython")
+        self.assertEqual(p.getGoal(Datetime(200101010000), 1.0), 0.0)
+
+        self.assertEqual(p._x, 0)
+        p._x = 10
+        self.assertEqual(p._x, 10)
+        self.assertEqual(p.getGoal(Datetime(200101010000), 1.0), 1.0)
+        p.reset()
+        self.assertEqual(p._x, 0)
+
+        p._x = 10
+        p_clone = p.clone()
+        self.assertEqual(p_clone._x, 10)
+        p.reset()
+        self.assertEqual(p._x, 0)
+        self.assertEqual(p_clone._x, 10)
+
+
+def testCrtPG(self):
+    pass
+
+
+def testGetGoal(self, datetime, price):
+    return 10.0 if datetime == Datetime(200101010000) else 0.0
+
+
+class TestCrtPG(unittest.TestCase):
+    def test_crt_pg(self):
+        p = crtPG(testCrtPG, params={'n': 10}, name="ProfitGoalPython")
+        p.getGoal = testGetGoal
+        self.assertEqual(p.name, "ProfitGoalPython")
+        self.assertEqual(p.getGoal(p, Datetime(200101010000), 1.0), 10.0)
+        self.assertEqual(p.getGoal(p, Datetime(200101020000), 1.0), 0.0)
+
+        p_clone = p.clone()
+        self.assertEqual(p_clone.name, "ProfitGoalPython")
+
+
+def suite():
+    return unittest.TestLoader().loadTestsFromTestCase(ProfitGoalTest)
+
+
+def suiteTestCrtPG():
+    return unittest.TestLoader().loadTestsFromTestCase(TestCrtPG)