Python run_python_code Examples

Example #1

File: doc_test.py Project: systemtrader/pyalgotrade-1

    def testExample1(self):
        with common.CopyFiles([os.path.join("testcases", "data", "bitstampUSD-2.csv")], "bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_1
bccharts_example_1.main()
"""
            common.run_python_code(code)
            lines = common.get_file_lines("30min-bitstampUSD.csv")
            self.assertTrue(common.compare_head("30min-bitstampUSD-2.csv", lines[0:10], "testcases/data"))
            self.assertTrue(common.compare_tail("30min-bitstampUSD-2.csv", lines[-10:], "testcases/data"))
            os.remove("30min-bitstampUSD.csv")

Example #2

    def testMarketTiming(self):
        files = []
        instruments = ["VTI", "VEU", "IEF", "VNQ", "DBC", "SPY"]
        for year in range(2007, 2013+1):
            for symbol in instruments:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        # The differences in the output are related to key ordering in dicts.
        if six.PY3:
            expected_output = "market_timing.output.37"
        else:
            expected_output = "market_timing.output.27"

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[-10:],
                common.tail_file(expected_output, 10)
            )

Example #3

    def testExample1(self):
        with common.CopyFiles(
            [os.path.join("testcases", "data", "bitstampUSD-2.csv")],
                "bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_1
bccharts_example_1.main()
"""
            res = common.run_python_code(code)
            lines = common.get_file_lines("30min-bitstampUSD.csv")
            os.remove("30min-bitstampUSD.csv")

            # Float str doesn't behave the same in Pyhton2 and Python3.
            if six.PY3:
                lines = lines[0:1] + [
                    round_csv_line(line, 5, 8) for line in lines[1:]
                ]

            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(
                lines[0:10],
                common.head_file("30min-bitstampUSD-2.csv",
                                 10,
                                 path="testcases/data"))
            self.assertEqual(
                lines[-10:],
                common.tail_file("30min-bitstampUSD-2.csv",
                                 10,
                                 path="testcases/data"))

Example #4

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testCSVFeed(self):
        with common.CopyFiles([os.path.join("samples", "data", "quandl_gold_2.csv")], "."):
            code = """import sys
sys.path.append('samples')
import csvfeed_1
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("csvfeed_1.output", lines[0:10]))
            self.assertTrue(common.compare_tail("csvfeed_1.output", lines[-10:-1]))

Example #5

    def testCSVFeed(self):
        with common.CopyFiles([os.path.join("samples", "data", "quandl_gold_2.csv")], "."):
            code = """import sys
sys.path.append('samples')
import csvfeed_1
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("csvfeed_1.output", lines[0:10]))
            self.assertTrue(common.compare_tail("csvfeed_1.output", lines[-10:-1]))

Example #6

File: logger_test.py Project: arippbbc/pyalgotrade

    def testBacktestingLog2(self):
            code = """from testcases import logger_test_2
logger_test_2.main()
"""
            lines = common.run_python_code(code).split("\n")
            self.assertEqual(len(lines), 4)
            self.assertEqual(lines[0], "2000-01-01 00:00:00 strategy [INFO] bla")
            self.assertTrue(lines[1].find("2000-01-02 00:00:00 broker.backtesting [DEBUG] Not enough money to fill order") == 0)
            self.assertEqual(lines[2], "2000-01-02 00:00:00 strategy [INFO] bla")
            self.assertEqual(lines[3], "")

Example #7

File: logger_test.py Project: aborodya/pyalgotrade

    def testBacktestingLog1(self):
        code = """from testcases import logger_test_1
logger_test_1.main()"""
        res = common.run_python_code(code)
        expectedLines = [
            "2000-01-01 00:00:00 strategy [INFO] bla",
            "2000-01-01 00:00:00 custom [INFO] ble",
        ]
        self.assertEqual(res.get_output_lines(), expectedLines)
        self.assertTrue(res.exit_ok())

Example #8

File: doc_test.py Project: systemtrader/pyalgotrade-1

    def testExample2(self):
        with common.CopyFiles([os.path.join("testcases", "data", "30min-bitstampUSD-2.csv")], "30min-bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_2
bccharts_example_2.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("bccharts_example_2.output", lines[0:10], "testcases/data"))
            self.assertTrue(common.compare_tail("bccharts_example_2.output", lines[-10:-1], "testcases/data"))

Example #9

File: doc_test.py Project: arippbbc/pyalgotrade

    def testTutorial1MtGox(self):
        with common.CopyFiles([os.path.join("samples", "data", "trades-mtgox-usd-2013-03.csv")], "."):
            code = """import sys
sys.path.append('samples')
import tutorial_mtgox_1
tutorial_mtgox_1.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("tutorial_mtgox_1.output", lines[0:10]))
            self.assertTrue(common.compare_tail("tutorial_mtgox_1.output", lines[-10:-1]))

Example #10

File: logger_test.py Project: systemtrader/pyalgotrade-1

    def testBacktestingLog2(self):
            code = """from testcases import logger_test_2
logger_test_2.main()
"""
            lines = common.run_python_code(code).split("\n")
            self.assertEqual(len(lines), 4)
            self.assertEqual(lines[0], "2000-01-01 00:00:00 strategy [INFO] bla")
            self.assertEqual(lines[1], "2000-01-02 00:00:00 broker.backtesting [DEBUG] Not enough cash to fill orcl order [1] for 1 share/s")
            self.assertEqual(lines[2], "2000-01-02 00:00:00 strategy [INFO] bla")
            self.assertEqual(lines[3], "")

Example #11

File: logger_test.py Project: Chin-I/pyalgotrade

    def testBacktestingLog1(self):
            code = """from testcases import logger_test_1
logger_test_1.main()
"""
            res = common.run_python_code(code)
            expectedLines = [
                "2000-01-01 00:00:00 strategy [INFO] bla",
                "2000-01-01 00:00:00 custom [INFO] ble",
            ]
            self.assertEqual(res.get_output_lines(), expectedLines)
            self.assertTrue(res.exit_ok())

Example #12

    def testBacktestingLog1(self):
        code = """from testcases import logger_test_1
logger_test_1.main()
"""
        lines = common.run_python_code(code).split("\n")
        expectedLines = [
            "2000-01-01 00:00:00 strategy [INFO] bla",
            "2000-01-01 00:00:00 custom [INFO] ble",
            "",
        ]
        self.assertEqual(lines, expectedLines)

Example #13

File: logger_test.py Project: arippbbc/pyalgotrade

    def testBacktestingLog1(self):
            code = """from testcases import logger_test_1
logger_test_1.main()
"""
            lines = common.run_python_code(code).split("\n")
            expectedLines = [
                "2000-01-01 00:00:00 strategy [INFO] bla",
                "2000-01-01 00:00:00 custom [INFO] ble",
                "",
            ]
            self.assertEqual(lines, expectedLines)

Example #14

    def testNonBacktestingLog3(self):
        code = """from testcases import logger_test_3
logger_test_3.main()
"""
        lines = common.run_python_code(code).split("\n")

        now = datetime.datetime.now()
        self.assertEqual(len(lines), 3)
        for line in lines[:-1]:
            self.assertEqual(line.find(str(now.date())), 0)
        self.assertNotEqual(lines[0].find("strategy [INFO] bla"), -1)
        self.assertNotEqual(lines[1].find("custom [INFO] ble"), -1)

Example #15

File: logger_test.py Project: arippbbc/pyalgotrade

    def testNonBacktestingLog3(self):
            code = """from testcases import logger_test_3
logger_test_3.main()
"""
            lines = common.run_python_code(code).split("\n")

            now = datetime.datetime.now()
            self.assertEqual(len(lines), 3)
            for line in lines[:-1]:
                self.assertEqual(line.find(str(now.date())), 0)
            self.assertNotEqual(lines[0].find("strategy [INFO] bla"), -1)
            self.assertNotEqual(lines[1].find("custom [INFO] ble"), -1)

Example #16

File: logger_test.py Project: 4ever911/DeepPupil

    def testNonBacktestingLog3(self):
            code = """from testcases import logger_test_3
logger_test_3.main()
"""
            res = common.run_python_code(code)

            now = datetime.datetime.now()
            self.assertEqual(len(res.get_output_lines()), 2)
            for line in res.get_output_lines(True):
                self.assertEqual(line.find(str(now.date())), 0)
            self.assertNotEqual(res.get_output_lines()[0].find("strategy [INFO] bla"), -1)
            self.assertNotEqual(res.get_output_lines()[1].find("custom [INFO] ble"), -1)
            self.assertTrue(res.exit_ok())

Example #17

File: logger_test.py Project: 4ever911/DeepPupil

    def testBacktestingLog2(self):
            code = """from testcases import logger_test_2
logger_test_2.main()
"""
            res = common.run_python_code(code)
            self.assertEqual(len(res.get_output_lines()), 3)
            self.assertEqual(res.get_output_lines()[0], "2000-01-01 00:00:00 strategy [INFO] bla")
            self.assertEqual(
                res.get_output_lines()[1],
                "2000-01-02 00:00:00 broker.backtesting [DEBUG] Not enough cash to fill orcl order [1] for 1 share/s"
            )
            self.assertEqual(res.get_output_lines()[2], "2000-01-02 00:00:00 strategy [INFO] bla")
            self.assertTrue(res.exit_ok())

Example #18

File: logger_test.py Project: aborodya/pyalgotrade

    def testBacktestingLog2(self):
        code = """from testcases import logger_test_2
logger_test_2.main()"""
        res = common.run_python_code(code)
        self.assertEqual(len(res.get_output_lines()), 3)
        self.assertEqual(res.get_output_lines()[0],
                         "2000-01-01 00:00:00 strategy [INFO] bla")
        self.assertEqual(
            res.get_output_lines()[1],
            "2000-01-02 00:00:00 pyalgotrade.broker.backtesting [DEBUG] Not enough USD to buy 1 orcl [order 1]"
        )
        self.assertEqual(res.get_output_lines()[2],
                         "2000-01-02 00:00:00 strategy [INFO] bla")
        self.assertTrue(res.exit_ok())

Example #19

    def testCSVFeed(self):
        with common.CopyFiles(
            [os.path.join("samples", "data", "quandl_gold_2.csv")], "."):
            code = """import sys
sys.path.append('samples')
import csvfeed_1
"""
            res = common.run_python_code(code)
            lines = res.get_output_lines(True)
            self.assertEqual(common.head_file("csvfeed_1.output", 10),
                             lines[0:10])
            self.assertEqual(common.tail_file("csvfeed_1.output", 10),
                             lines[-10:])
            self.assertTrue(res.exit_ok())

Example #20

File: doc_test.py Project: oliveagle/pyalgotrade

    def testTutorial1MtGox(self):
        with common.CopyFiles(
            [os.path.join("samples", "data", "trades-mtgox-usd-2013-03.csv")],
                "."):
            code = """import sys
sys.path.append('samples')
import tutorial_mtgox_1
tutorial_mtgox_1.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(
                common.compare_head("tutorial_mtgox_1.output", lines[0:10]))
            self.assertTrue(
                common.compare_tail("tutorial_mtgox_1.output", lines[-10:-1]))

Example #21

    def testExample2(self):
        with common.CopyFiles(
            [os.path.join("testcases", "data", "30min-bitstampUSD-2.csv")],
                "30min-bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_2
bccharts_example_2.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(res.get_output_lines()[0:10],
                             common.head_file("bccharts_example_2.output", 10))
            self.assertEqual(res.get_output_lines()[-10:],
                             common.tail_file("bccharts_example_2.output", 10))

Example #22

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testBBands(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["yhoo"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import bbands
bbands.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("bbands.output", lines[-2:-1]))

Example #23

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testEventStudy(self):
        files = []
        for year in range(2008, 2010):
            for symbol in ["AA", "AES", "AIG"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import eventstudy
eventstudy.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("eventstudy.output", lines[-2:-1]))

Example #24

File: doc_test.py Project: oliveagle/pyalgotrade

    def testBBands(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["yhoo"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import bbands
bbands.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("bbands.output", lines[-2:-1]))

Example #25

    def testErnieChanGldVsGdx(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["gld", "gdx"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import statarb_erniechan
statarb_erniechan.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("statarb_erniechan.output", lines[-2:-1]))

Example #26

    def testEventStudy(self):
        files = []
        for year in range(2008, 2010):
            for symbol in ["AA", "AES", "AIG"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import eventstudy
eventstudy.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("eventstudy.output", lines[-2:-1]))

Example #27

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testErnieChanGldVsGdx(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["gld", "gdx"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import statarb_erniechan
statarb_erniechan.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("statarb_erniechan.output", lines[-2:-1]))

Example #28

File: doc_test.py Project: 363158858/pyalgotrade-cn

    def testRSI2(self):
        files = []
        for year in range(2009, 2013):
            for symbol in ["DIA"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import rsi2_sample
rsi2_sample.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(common.compare_tail("rsi2_sample.output", res.get_output_lines()[-2:-1]))
            self.assertTrue(res.exit_ok())

Example #29

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testQuandl(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["GORO"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))
        files.append(os.path.join("samples", "data", "quandl_gold_2.csv"))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import quandl_sample
quandl_sample.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("quandl_sample.output", lines[0:10]))
            self.assertTrue(common.compare_tail("quandl_sample.output", lines[-10:-1]))

Example #30

    def testBBands(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["yhoo"]:
                fileName = "%s-%d-googlefinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import bbands
bbands.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(res.get_output_lines()[-1:],
                             common.tail_file("bbands.output", 1))

Example #31

    def testEventStudy(self):
        files = []
        for year in range(2008, 2010):
            for symbol in ["AA", "AES", "AIG"]:
                fileName = "%s-%d-googlefinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import eventstudy
eventstudy.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(res.get_output_lines()[-1:],
                             common.tail_file("eventstudy.output", 1))

Example #32

    def testMarketTiming(self):
        common.init_temp_path()
        files = []
        instruments = ["MSFT", "ORCL", "IBM", "HPQ", "WMT", "UPS", "TGT", "CCL", "XOM", "CVX", "COP", "OXY", "BAC", "JPM", "WFC", "GS", "PG", "PEP", "CL", "KO"]
        for year in range(2005, 2013+1):
            for symbol in instruments:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "data"):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("market_timing.output", lines[-10:-1]))

Example #33

File: doc_test.py Project: gansaihua/pyalgotrade

    def testCSVFeed(self):
        with common.CopyFiles([os.path.join("samples", "data", "quandl_gold_2.csv")], "."):
            code = """import sys
sys.path.append('samples')
import csvfeed_1
"""
            res = common.run_python_code(code)
            lines = res.get_output_lines(True)
            self.assertEqual(
                common.head_file("csvfeed_1.output", 10),
                lines[0:10]
            )
            self.assertEqual(
                common.tail_file("csvfeed_1.output", 10),
                lines[-10:]
            )
            self.assertTrue(res.exit_ok())

Example #34

    def testMarketTiming(self):
        common.init_temp_path()
        files = []
        instruments = ["VTI", "VEU", "IEF", "VNQ", "DBC", "SPY"]
        for year in range(2007, 2013+1):
            for symbol in instruments:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "data"):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("market_timing.output", lines[-10:-1]))

Example #35

    def testQuandl(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["GORO"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))
        files.append(os.path.join("samples", "data", "quandl_gold_2.csv"))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import quandl_sample
quandl_sample.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_head("quandl_sample.output", lines[0:10]))
            self.assertTrue(common.compare_tail("quandl_sample.output", lines[-10:-1]))

Example #36

    def testVWAPMomentum(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["AAPL"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import vwap_momentum
vwap_momentum.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(res.get_output_lines()[-1:],
                             common.tail_file("vwap_momentum.output", 1))

Example #37

File: doc_test.py Project: Greenwicher/pyalgotrade

    def testMarketTiming(self):
        common.init_temp_path()
        files = []
        instruments = ["VTI", "VEU", "IEF", "VNQ", "DBC", "SPY"]
        for year in range(2007, 2013+1):
            for symbol in instruments:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "data"):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            lines = common.run_python_code(code).split("\n")
            self.assertTrue(common.compare_tail("market_timing.output", lines[-10:-1]))

Example #38

File: doc_test.py Project: gansaihua/pyalgotrade

    def testExample2(self):
        with common.CopyFiles([os.path.join("testcases", "data", "30min-bitstampUSD-2.csv")], "30min-bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_2
bccharts_example_2.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(
                res.get_output_lines()[0:10],
                common.head_file("bccharts_example_2.output", 10, path="testcases/data")
            )
            self.assertEqual(
                res.get_output_lines()[-10:],
                common.tail_file("bccharts_example_2.output", 10, path="testcases/data")
            )

Example #39

    def testErnieChanGldVsGdx(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["gld", "gdx"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """
from samples import statarb_erniechan
statarb_erniechan.main(False)
"""
            res = common.run_python_code(code)

            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(res.get_output_lines()[-1:],
                             common.tail_file("statarb_erniechan.output", 1))

Example #40

File: doc_test.py Project: tate11/intelligent-code-completion

    def testRSI2(self):
        files = []
        for year in range(2009, 2013):
            for symbol in ["DIA"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import rsi2_sample
rsi2_sample.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(
                common.compare_tail("rsi2_sample.output",
                                    res.get_output_lines()[-2:-1]))
            self.assertTrue(res.exit_ok())

Example #41

File: doc_test.py Project: gansaihua/pyalgotrade

    def testErnieChanGldVsGdx(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["gld", "gdx"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """
from samples import statarb_erniechan
statarb_erniechan.main(False)
"""
            res = common.run_python_code(code)

            self.assertTrue(res.exit_ok(), res.get_output())
            self.assertEqual(
                res.get_output_lines()[-1:],
                common.tail_file("statarb_erniechan.output", 1)
            )

Example #42

File: doc_test.py Project: 363158858/pyalgotrade-cn

    def testErnieChanGldVsGdx(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["gld", "gdx"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import statarb_erniechan
statarb_erniechan.main(False)
"""
            res = common.run_python_code(code)
            obtained = res.get_output_lines()[-2]
            expected = common.tail_file("statarb_erniechan.output", 1)[0]
            self.assertEquals(expected, obtained, "Got this lines %s instead" % (res.get_output_lines()))
            # self.assertTrue(common.compare_tail("statarb_erniechan.output", res.get_output_lines()[-2:-1]))
            self.assertTrue(res.exit_ok())

Example #43

    def testMarketTiming(self):
        init_data_path()
        files = []
        instruments = ["VTI", "VEU", "IEF", "VNQ", "DBC", "SPY"]
        for year in range(2007, 2013 + 1):
            for symbol in instruments:
                fileName = "%s-%d-googlefinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "data"):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(res.get_output_lines()[-10:],
                             common.tail_file("market_timing.output", 10))

Example #44

File: doc_test.py Project: gansaihua/pyalgotrade

    def testBBands(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["yhoo"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import bbands
bbands.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[-10:],
                common.tail_file("bbands.output", 10)
            )

Example #45

File: doc_test.py Project: gansaihua/pyalgotrade

    def testEventStudy(self):
        files = []
        for year in range(2008, 2010):
            for symbol in ["IBM", "AES", "AIG"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import eventstudy
eventstudy.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[-1:],
                common.tail_file("eventstudy.output", 1)
            )

Example #46

    def testQuandl(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["GORO"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))
        files.append(os.path.join("samples", "data", "quandl_gold_2.csv"))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import quandl_sample
quandl_sample.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(res.get_output_lines()[0:10],
                             common.head_file("quandl_sample.output", 10))
            self.assertEqual(res.get_output_lines()[-10:],
                             common.tail_file("quandl_sample.output", 10))

Example #47

    def testSMACrossOver(self):
        files = []
        for year in range(2011, 2013):
            for symbol in ["aapl"]:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import sma_crossover_sample
sma_crossover_sample.main(False)
"""
            res = common.run_python_code(code)

            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[-1:],
                common.tail_file("sma_crossover.output", 1)
            )

Example #48

    def testExample1(self):
        with common.CopyFiles([os.path.join("testcases", "data", "bitstampUSD-2.csv")], "bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_1
bccharts_example_1.main()
"""
            res = common.run_python_code(code)
            lines = common.get_file_lines("30min-bitstampUSD.csv")
            os.remove("30min-bitstampUSD.csv")

            self.assertTrue(res.exit_ok())
            self.assertEqual(
                lines[0:10],
                common.head_file("30min-bitstampUSD-2.csv", 10, path="testcases/data")
            )
            self.assertEqual(
                lines[-10:],
                common.tail_file("30min-bitstampUSD-2.csv", 10, path="testcases/data")
            )

Example #49

File: doc_test.py Project: Chin-I/pyalgotrade

    def testMarketTiming(self):
        init_data_path()
        files = []
        instruments = ["VTI", "VEU", "IEF", "VNQ", "DBC", "SPY"]
        for year in range(2007, 2013+1):
            for symbol in instruments:
                fileName = "%s-%d-yahoofinance.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))

        with common.CopyFiles(files, "data"):
            code = """import sys
sys.path.append('samples')
import market_timing
market_timing.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[-10:],
                common.tail_file("market_timing.output", 10)
            )

Example #50

File: doc_test.py Project: gansaihua/pyalgotrade

    def testExample1(self):
        with common.CopyFiles([os.path.join("testcases", "data", "bitstampUSD-2.csv")], "bitstampUSD.csv"):
            code = """import sys
sys.path.append('samples')
import bccharts_example_1
bccharts_example_1.main()
"""
            res = common.run_python_code(code)
            lines = common.get_file_lines("30min-bitstampUSD.csv")
            os.remove("30min-bitstampUSD.csv")

            # Float str doesn't behave the same in Pyhton2 and Python3.
            if six.PY3:
                lines = lines[0:1] + [round_csv_line(line, 5, 8) for line in lines[1:]]

            self.assertTrue(res.exit_ok())
            self.assertEqual(
                lines[0:10],
                common.head_file("30min-bitstampUSD-2.csv", 10, path="testcases/data")
            )
            self.assertEqual(
                lines[-10:],
                common.tail_file("30min-bitstampUSD-2.csv", 10, path="testcases/data")
            )

Example #51

File: doc_test.py Project: gansaihua/pyalgotrade

    def testQuandl(self):
        files = []
        for year in range(2006, 2013):
            for symbol in ["GORO"]:
                fileName = "WIKI-%s-%d-quandl.csv" % (symbol, year)
                files.append(os.path.join("samples", "data", fileName))
        files.append(os.path.join("samples", "data", "quandl_gold_2.csv"))

        with common.CopyFiles(files, "."):
            code = """import sys
sys.path.append('samples')
import quandl_sample
quandl_sample.main(False)
"""
            res = common.run_python_code(code)
            self.assertTrue(res.exit_ok())
            self.assertEqual(
                res.get_output_lines()[0:10],
                common.head_file("quandl_sample.output", 10)
            )
            self.assertEqual(
                res.get_output_lines()[-10:],
                common.tail_file("quandl_sample.output", 10)
            )