def Main(msg): """ 获取微信消息,进行处理指令、关键词监听、撤回消息监听的动作 :param msg: 微信消息 :return: 无 """ # 三大功能之一:处理指令 itchat.get_friends(update=True) if msg['ToUserName'] == "filehelper" and msg['Type'] == "Text": try: exec_command = Execution() exec_command.Execution(msg) except BaseException as e: mylog.WriteLog(e) # 三大功能之二:撤回消息部分 try: rmsg = Revocation() rmsg.SaveMsg(msg) rmsg.Revocation(msg) rmsg.ClearTimeOutMsg() except BaseException as e: mylog.WriteLog(e) # 三大功能之三:关键词监听 if msg['Type'] in ['Text', 'Sharing', 'Map', 'Card']: try: listener = KeywordListener() listener.Listener(msg) except BaseException as e: mylog.WriteLog(e)
class ExecutionTestCase(unittest.TestCase): """ Test methods in Execution """ def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) self.pkg_dir = os.path.join('..') self.execution = Execution(self.pkg_dir) self.img_size = 160 def test_create_wh(self): """ The warehouse should be a dictionary of UID keys and Person values :return: None """ directory = os.path.join(self.pkg_dir, 'dataset', 'test') warehouse = self.execution.create_wh(directory) condition = len(warehouse.get_samples()) > 0 self.assertEqual(condition, True) def test_acquire_data(self): """ This function should create two warehouses and populate them with samples :return: None """ self.execution.acquire_data() condition0 = len( self.execution.data_acquisition.trn_wh.get_samples()) > 0 condition1 = len( self.execution.data_acquisition.tst_wh.get_samples()) > 0 condition = condition0 and condition1 self.assertEqual(condition, True)
def testTestDetailsWithExecution(self): t0 = Test(1, "Test 0", "1111") t0.description = "This is my test" t0.add_parameter("tparam0", "tvalue1") t0.add_parameter("tparam1", "tvalue2") t0.add_property("tprop0", "tvalue0") t0.add_property("tprop1", "tvalue1") t1 = Test(2, "Test 2", "2222") t1.set_status("error") t2 = Test(3, "Test 3", "3333") t2.set_status("failure") s0 = Scenario("Scenario 0") s0.add_scenario_property("foo0", "bar0") s0.add_scenario_property("foo1", "bar1") s0.add_child(t0) s0.add_child(t1) s0.add_child(t2) m0 = Machine("Itai's desktop") m0.add_child(s0) e = Execution() e.add_machine(m0) print(json.dumps(e.dict()))
def Initialize(self): self.SetStartDate(2003, 1, 1) self.SetCash(100000) # Data resolution self.UniverseSettings.Resolution = Resolution.Minute # Universe selection model self.securities = [] self.CustomUniverseSelectionModel = FactorUniverseSelectionModel(self) self.AddUniverse(self.CustomUniverseSelectionModel.SelectCoarse, self.CustomUniverseSelectionModel.SelectFine) # Alpha model self.CustomAlphaModel = ValueAlphaModel() # Portfolio construction model self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel() # Execution model self.CustomExecution = Execution() # Add SPY for trading days data self.AddEquity('SPY', Resolution.Daily) # Schedule rebalancing self.Schedule.On(self.DateRules.EveryDay('SPY'), self.TimeRules.At(13, 0), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday), self.TimeRules.BeforeMarketClose('SPY', 0), Action(self.PlotCharts))
def main(): logging_config() cfg_file = sys.argv[1] code_dir = os.path.dirname( os.path.abspath(inspect.getfile(inspect.currentframe()))) execution = Execution(code_dir) helper = ExecConfHelper() helper.build(execution, cfg_file) helper = ExecDnsHelper(execution) helper.setup_dns() execution.run()
def init_model(self): self.execution = Execution() machine = Machine(socket.gethostname()) machine.planned_tests = self.general_conf.get_int("planned.tests") self.execution.add_machine(machine) self.uid = str(randint(1000, 9999) + time.time() / 1000).replace( ".", "") self.index = 0 self.scenario_stack = [] self.buffered_elements = [] self.testDetails = None
def create_list_Executions_object(list_metrics, flag): list_objects = [] i = 0 for each in list_metrics: x = Execution(i, each) list_objects.append(x) if(flag): x.show() i = i + 1 return list_objects
def DBMSMainMenu(username): while (True): print('User in session: ' + username) logging.warning('User in session: ' + username) userInput = functions.display_DBMS_options() if (userInput == "1"): Execution.ExecutionMenu(username) elif (userInput == "2"): with open(db_log, 'r') as f: for line in f: print(line) elif (userInput == "3"): db_name = input("Enter a DB Name: ") with open(dd_path + db_name + '.json', 'r') as f: for line in f: print(line) elif (userInput == "4"): dbname = input("Enter a new Database Name: ") createDump(dbname) elif (userInput == "5"): dbname = input("Enter a new Database Name: ") generateERD(dbname) elif (userInput == "6"): isLoggedIn = user_class.User.logOut() break else: print("Please enter a valid option...") print("\n")
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', a decimal number, or a fraction. """ invocation = execution.invocation log = execution.concatenate_logs() pos = log.find("+ Property {}".format(benchmark.get_property_name())) if pos < 0: return None pos = log.find("Probability: ", pos) if pos < 0: pos = log.find("Value: ") if pos < 0: pos = log.find("Result: ") if pos < 0: return None else: pos = pos + len("Result: ") eol_pos = log.find("\n", pos) return log[pos:eol_pos].lstrip() else: pos = pos + len("Value: ") eol_pos = log.find("\n", pos) return log[pos:eol_pos] else: pos = pos + len("Probability: ") eol_pos = log.find("\n", pos) return log[pos:eol_pos]
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', or a decimal number. """ invocation = execution.invocation log = execution.concatenate_logs() if "PRISM-games" in log: # SMC pos = log.find("Result (maximum probability): ") if pos < 0: pos = log.find("Result (minimum probability): ") if pos < 0: return None pos = pos + len("Result (---imum probability): ") eol_pos = log.find("\n", pos) return log[pos:eol_pos] else: # PET pos = log.find("Output:\n") if pos < 0: return None pos = pos + len("Output:\n") eol_pos = log.find("\n", pos) if pos == eol_pos: return None return log[pos:eol_pos]
def check_donaways_eod(date_i): while done_away_orders.has_order(): o = done_away_orders.pop_order() day_return.add_transaction(o.qty, o.price) e = Execution(o.qty, o.symbol, o.price, date_i) executions.append(e) trades.add_execution(e)
class TradingBot(QCAlgorithm): def Initialize(self): self.SetStartDate(2019, 1, 1) self.SetEndDate(2020, 1, 1) self.SetCash(100000) # Data resolution # By default, assets selected by universe selection are requested with minute resolution data. # https://www.quantconnect.com/docs/algorithm-reference/universes self.UniverseSettings.Resolution = Resolution.Minute self.UniverseSettings.Leverage = 1 # Universe selection model self.securities = [] self.CustomUniverseSelectionModel = FactorUniverseSelectionModel(self) self.AddUniverse(self.CustomUniverseSelectionModel.SelectCoarse, self.CustomUniverseSelectionModel.SelectFine) # Alpha model self.CustomAlphaModel = ValueAlphaModel() # Portfolio construction model self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel( turnover=0.05, max_wt=0.05, longshort=True) # Execution model self.CustomExecution = Execution(liq_tol=0.005) # Add SPY for trading days data self.AddEquity('SPY', Resolution.Daily) # Schedule rebalancing self.Schedule.On(self.DateRules.EveryDay('SPY'), self.TimeRules.At(13, 0), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday), self.TimeRules.BeforeMarketClose('SPY', 0), Action(self.PlotCharts)) def OnData(self, data): pass def RebalancePortfolio(self): alpha_df = self.CustomAlphaModel.GenerateAlphaScores( self, self.securities) portfolio = self.CustomPortfolioConstructionModel.GenerateOptimalPortfolio( self, alpha_df) self.CustomExecution.ExecutePortfolio(self, portfolio) def PlotCharts(self): PlotPerformanceChart(self) PlotPosConcentrationChart(self) PlotStockCountChart(self) PlotExposureChart(self)
class TradingBot(QCAlgorithm): def Initialize(self): self.SetStartDate(2020, 1, 1) self.SetEndDate(datetime.now() - timedelta(10)) self.SetCash(100000) # *Data Resolution self.UniverseSettings.Resolution = Resolution.Minute # *Universe selection model; runs with the above data resolution # custom universe selection model class created -- from universe_selection -->UniverseSelectionModel() self.securities = [] self.CustomUniverseSelectionModel = FactorUniverseSelectionModel(self) self.AddUniverse(self.CustomUniverseSelectionModel.SelectCoarse, self.CustomUniverseSelectionModel.SelectFine) # *Alpha model; A self.CustomAlphaModel = ValueAlphaModel() # *Portfolio construction model; B self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel( turnover=0.05, max_wt=0.05, longshort=True) #Eexecution model; C self.CustomExecution = Execution(liq_tol=0.005) # *Add SPY for trading days data; a self.AddEquity('SPY', Resolution.Daily) # *Scheduling rebalancing; b ; we take the a daily resloution and at 2 oclock we execute a rebalance self.Schedule.On(self.DateRules.EveryDay('SPY'), self.TimeRules.At(13, 0), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday), self.TimeRules.BeforeMarketClose('SPY', 0), Action(self.PlotCharts)) def OnData(self, data): pass # this controls the A B C ; we chose when we rebalance; we generate our alpha scores ;we pass the alpha scores into our portfolio construction #next we execute orders based on our portfolio construction def RebalancePortfolio(self): alpha_df = self.CustomAlphaModel.GenerateAlphaScores( self, self.securities) portfolio = self.CustomPortfolioConstructionModel.GenerateOptimalPortfolio( self, alpha_df) self.CustomExecution.ExecutePortfolio(self, portfolio) def PlotCharts(self): PlotPerformanceChart(self) PlotPosConcentrationChart(self) PlotStockCountChart(self) PlotExposureChart(self)
def build_workout_sample(): workout1 = Workout() workout1.date = '2018-02-19' execution1 = Execution() execution1.exercise = build_exercise_sample() set1, set2, set3 = Set(), Set(), Set() set1.start_time = '2018-02-19T16:10:35Z' set1.repetitions = 10 set1.weight = 40 set2.start_time = '2018-02-19T16:12:35Z' set2.repetitions = 9 set2.weight = 42 set3.start_time = '2018-02-19T16:14:35Z' set3.repetitions = 8 set3.weight = 42 execution1.sets = [set1, set2, set3] workout1.executions = [execution1] return workout1
def Initialize(self): self.SetStartDate(2017, 1, 1) # Set Start Date self.SetEndDate(2020, 5, 20) self.SetCash(100000) # Set Strategy Cash # Weighting style - normalise or alpha_max (alpha maximisation w/ optimisation) self.weighting_style = 'normalise' # Market neutral self.mkt_neutral = True # Audio feature to use self.audio_feature = 'valence' # Get data self.data, self.etf_list, self.etf_country = self.DataSetup() # Add ETFs for etf in self.etf_list: self.AddEquity(etf, Resolution.Minute) # Portfolio construction model self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel( turnover=1, max_wt=0.2, longshort=True, mkt_neutral=self.mkt_neutral) # Execution model self.CustomExecution = Execution(liq_tol=0.005) # Schedule rebalancing self.Schedule.On(self.DateRules.Every(DayOfWeek.Wednesday), self.TimeRules.BeforeMarketClose('IVV', 210), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Wednesday), self.TimeRules.BeforeMarketClose('IVV', 5), Action(self.PlotCharts))
def initialize(self, initial_capital: float, mq_ip: str, hook_ip: str, trading_environment: str, trading_universe: list, datatypes: list, txn_cost: float = 30, cache_rows: int = 3000, test_mq_con=True, hook_name: str = 'FUTU', prefill_period='1Y', **kwargs): assert trading_environment in ( 'BACKTEST', 'SIMULATE', 'REAL'), f'Invalid trading environment {trading_environment}' assert initial_capital > 0, 'Initial Capital cannot be 0' assert cache_rows > 1, 'No of cached data must be > 0 rows' self._account = Account(logger=self._logger, initial_capital=initial_capital, txn_cost=txn_cost) self._data = Data(mq_ip=mq_ip, logger=self._logger, hook_ip=hook_ip, trading_universe=trading_universe, datatypes=datatypes, cache_rows=cache_rows, test_mq_con=test_mq_con, hook_name=hook_name, prefill_period=prefill_period, add_pos_func=self._account.add_new_position) self._execution = Execution(account=self._account, data=self._data, trading_environment=trading_environment, logger=self._logger) self._webapp = AlgoApp(algo=self) self._initialized_date = datetime.datetime.today() self._running = False self._logger.debug('Initialized sucessfully.') self._initialized = True
def __init__(self, challenger, champion, placementRule, placementOption, existRule, existOption, actionRule, actionOption, endingRule, endingOption, objectCount, gameBoard, dataBoard, scriptPath=None, problemIndex='scriptTemplate'): if type(challenger) is not UserProgram and type( champion) is not UserProgram: raise TypeError if scriptPath: sys.path.insert(0, scriptPath) exec 'from {0} import UserRule'.format(problemIndex) # parameter setting self.challenger = challenger self.champion = champion self.data = GameData(objectCount, placementRule, placementOption, existRule, existOption, actionRule, actionOption, endingRule, endingOption, gameBoard, dataBoard) self.limitTime = 2000 self.positionData = '' self.boardData = '' # make rule and execution object self.rules = UserRule() self.execution = Execution() self.changePlayerNBoard(True, ' ')
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', a decimal number, or a fraction. """ invocation = execution.invocation log = execution.concatenate_logs() return grep_for_result(benchmark, log)
class TradingBot(QCAlgorithm): def Initialize(self): self.SetStartDate(2003, 1, 1) self.SetCash(100000) # Data resolution self.UniverseSettings.Resolution = Resolution.Minute # Universe selection model self.securities = [] self.CustomUniverseSelectionModel = FactorUniverseSelectionModel(self) self.AddUniverse(self.CustomUniverseSelectionModel.SelectCoarse, self.CustomUniverseSelectionModel.SelectFine) # Alpha model self.CustomAlphaModel = ValueAlphaModel() # Portfolio construction model self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel( ) # Execution model self.CustomExecution = Execution() # Add SPY for trading days data self.AddEquity('SPY', Resolution.Daily) # Schedule rebalancing self.Schedule.On(self.DateRules.EveryDay('SPY'), self.TimeRules.At(13, 0), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday), self.TimeRules.BeforeMarketClose('SPY', 0), Action(self.PlotCharts)) def OnData(self, data): pass def RebalancePortfolio(self): alpha_df = self.CustomAlphaModel.GenerateAlphaScores( self, self.securities) portfolio = self.CustomPortfolioConstructionModel.GenerateOptimalPortfolio( self, alpha_df) self.CustomExecution.ExecutePortfolio(self, portfolio) def PlotCharts(self): PlotPerformanceChart(self) PlotPosConcentrationChart(self)
def Initialize(self): self.SetStartDate(2020, 1, 1) self.SetEndDate(datetime.now() - timedelta(10)) self.SetCash(100000) # *Data Resolution self.UniverseSettings.Resolution = Resolution.Minute # *Universe selection model; runs with the above data resolution # custom universe selection model class created -- from universe_selection -->UniverseSelectionModel() self.securities = [] self.CustomUniverseSelectionModel = FactorUniverseSelectionModel(self) self.AddUniverse(self.CustomUniverseSelectionModel.SelectCoarse, self.CustomUniverseSelectionModel.SelectFine) # *Alpha model; A self.CustomAlphaModel = ValueAlphaModel() # *Portfolio construction model; B self.CustomPortfolioConstructionModel = OptimisationPortfolioConstructionModel( turnover=0.05, max_wt=0.05, longshort=True) #Eexecution model; C self.CustomExecution = Execution(liq_tol=0.005) # *Add SPY for trading days data; a self.AddEquity('SPY', Resolution.Daily) # *Scheduling rebalancing; b ; we take the a daily resloution and at 2 oclock we execute a rebalance self.Schedule.On(self.DateRules.EveryDay('SPY'), self.TimeRules.At(13, 0), Action(self.RebalancePortfolio)) # Init charting InitCharts(self) # Schedule charting self.Schedule.On(self.DateRules.Every(DayOfWeek.Friday), self.TimeRules.BeforeMarketClose('SPY', 0), Action(self.PlotCharts))
def testSimpleModel(self): expected = {'machines': [{'status': 'success', 'type': 'machine', 'name': "Itai's desktop", 'children': [{'status': 'success', 'children': [{'status': 'success', 'index': 1, 'uid': '1111', 'parameters': {'tparam0': 'tvalue1', 'tparam1': 'tvalue2'}, 'timestamp': '', 'name': 'Test 0', 'className': '', 'duration': 0, 'type': 'test', 'properties': {'tprop1': 'tvalue1', 'tprop0': 'tvalue0'}, 'description': 'This is my test'}, {'status': 'error', 'index': 2, 'uid': '2222', 'parameters': {}, 'timestamp': '', 'name': 'Test 2', 'className': '', 'duration': 0, 'type': 'test', 'properties': {}, 'description': ''}, {'status': 'failure', 'index': 3, 'uid': '3333', 'parameters': {}, 'timestamp': '', 'name': 'Test 3', 'className': '', 'duration': 0, 'type': 'test', 'properties': {}, 'description': ''}], 'type': 'scenario', 'name': 'Scenario 0', 'scenarioProperties': {'foo0': 'bar0', 'foo1': 'bar1'}}]}]} t0 = Test(1, "Test 0", "1111") t0.description = "This is my test" t0.add_parameter("tparam0", "tvalue1") t0.add_parameter("tparam1", "tvalue2") t0.add_property("tprop0", "tvalue0") t0.add_property("tprop1", "tvalue1") t1 = Test(2, "Test 2", "2222") t1.set_status("error") t2 = Test(3, "Test 3", "3333") t2.set_status("failure") s0 = Scenario("Scenario 0") s0.add_scenario_property("foo0", "bar0") s0.add_scenario_property("foo1", "bar1") s0.add_child(t0) s0.add_child(t1) s0.add_child(t2) m0 = Machine("Itai's desktop") m0.add_child(s0) e = Execution() e.add_machine(m0) print (e.dict()) self.assertDictEqual(expected, e.dict())
def start(): global project, tracer, inspector try: project = Project.from_directory(find_project_directory(os.getcwd())) execution = Execution(project) inspector = Inspector(execution) tracer = Tracer(inspector) tracer.btracer.setup() sys.settrace(tracer.tracer) except PythoscopeDirectoryMissing: print "Can't find .pythoscope/ directory for this project. " \ "Initialize the project with the '--init' option first. " \ "Pythoscope tracing disabled for this run."
def run(self): number_of_process = int(os.cpu_count() / 2) print(self._path_out) print(os.listdir(self._path_out)) exams_exists = ['{}.mp4'.format(x) for x in os.listdir(self._path_out)] if len(self._list_available) > 0: list_exams = [ x for x in self._list_available if ('.mp4' in x) and (x not in exams_exists) ] else: list_exams = [ x for x in os.listdir(self._path_dataset) if ('.mp4' in x) and (x not in exams_exists) ] list_exams = ['benchmark_final.avi'] process = [] while len(list_exams) > 0: end_list = number_of_process if len( list_exams) > number_of_process else len(list_exams) list_process = list_exams[0:end_list] list_exams = list_exams[end_list:len(list_exams)] for exam in list_process: title = exam.replace('.avi', '') paths = { 'path_exam': '{}/{}'.format(self._path_dataset, exam), 'path_information': '{}/{}.log'.format(self._path_information, title), 'path_out': '{}/{}'.format(self._path_out, title), 'path_label': '{}/{}_label.csv'.format(self._path_label, title) } self._make_path(paths['path_out']) execution = Execution() thread = Process(target=execution.pupil_process, args=(paths, )) process.append(thread) thread.start() for thread in process: thread.join()
def check_fills(row): while done_away_orders.has_order(): o = done_away_orders.pop_order() day_return.add_transaction(o.qty, o.price) e = Execution(o.qty, o.symbol, o.price, row.name) executions.append(e) trades.add_execution(e) orders = open_orders.get_open_orders(row['symbol']) if orders is not None: for o in orders[:]: if is_fill(o, row): record_fill(o, row) orders.remove(o)
def record_fill(o, row): fill_price = 0.0 if o.price == 0: fill_price = float(row['open']) else: if o.qty > 0: fill_price = min(o.price, row['open']) elif o.qty < 0: fill_price = max(o.price, row['open']) day_return.add_transaction(o.qty, fill_price) e = Execution(o.qty, o.symbol, fill_price, row.name) executions.append(e) trades.add_execution(e)
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', a decimal number, or a fraction. """ invocation = execution.invocation log = execution.concatenate_logs() RESULT_MARKER = "point estimate: " pos = log.find(RESULT_MARKER) if pos < 0: return None pos = pos + len(RESULT_MARKER) eol_pos = log.find(",", pos) return log[pos:eol_pos]
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', a decimal number, or a fraction. """ invocation = execution.invocation log = execution.concatenate_logs() pos = log.find("command-check-result-is ") if pos < 0: return None pos += len("command-check-result-is ") eol_pos = log.find("\n", pos) space_pos = log.find(" ", pos) if (eol_pos < space_pos): return log[pos:eol_pos].rstrip() else: return log[pos:space_pos].rstrip()
def get_result(benchmark: Benchmark, execution: Execution): """ Returns the result of the given execution on the given benchmark. This method is called after executing the commands of the associated invocation. One can either find the result in the tooloutput (as done here) or read the result from a file that the tool has produced. The returned value should be either 'true', 'false', a decimal number, or a fraction. """ invocation = execution.invocation log = execution.concatenate_logs() if "Storm-dft" in log: pos = log.find("Result: [") if pos >= 0: pos = pos + len("Result: [") pos_e = log.find("]\n", pos) if pos_e >= 0: return log[pos:pos_e] pos1 = log.find("Model checking property \"{}\":".format( benchmark.get_property_name())) if pos1 < 0: return None for pre_result_str in [ "Result (for initial states): ", "Result till abort (for initial states): " ]: pos2 = log.find(pre_result_str, pos1) if pos2 < 0: continue pos2 += len(pre_result_str) eol_pos = log.find("\n", pos2) result = log[pos2:eol_pos] pos_appr = result.find("(approx. ") if pos_appr >= 0: result = result[:pos_appr] return result return None
def newInteration(lines, learnFactor, logger): execution = Execution(learnFactor, logger); linesTraining, linesTeste = execution.separateTrainingTestesLines(lines); execution.training(linesTraining); results = execution.testing(linesTeste); print(results); tableResults = Measures.getTableResults(results); accuracy = Measures.accuracy(tableResults) precision = Measures.precision(tableResults) recall = Measures.recall(tableResults) f1_score = Measures.f1_score(precision, recall) print('\naccuracy: ' + str(accuracy) + '% ' + 'precision: ' + str(precision) + '% ' + 'recall: ' + str(recall) + '% ' + 'f1_score: ' + str(f1_score) + '%'); return accuracy, precision, recall, f1_score;
# Trade GBP/USD instrument = "GBP_USD" # Create the OANDA market price streaming class # making sure to provide authentication commands prices = StreamingForexPrices(STREAM_DOMAIN, ACCESS_TOKEN, ACCOUNT_ID, instrument, events) # Create the strategy/signal generator, passing the # instrument and the events queue strategy = TestStrategy(instrument, events) # Create the portfolio object that will be used to # compare the OANDA positions with the local, to # ensure backtesting integrity. portfolio = Portfolio(prices, events, equity=100000.0) # Create the execution handler making sure to # provide authentication commands execution = Execution(API_DOMAIN, ACCESS_TOKEN, ACCOUNT_ID) # Create two separate threads: One for the trading loop # and another for the market price streaming class trade_thread = threading.Thread(target=trade, args=(events, strategy, portfolio, execution)) price_thread = threading.Thread(target=prices.stream_to_queue, args=[]) # Start both threads trade_thread.start() price_thread.start()
def execute(self): execution = Execution(self) execution.run() return execution
RESTaccess.socketIO = SocketIO(RESTaccess.TRADING_API_URL, RESTaccess.WEBSOCKET_PORT, params={'access_token': RESTaccess.ACCESS_TOKEN}) RESTaccess.socketIO.on('connect', RESTaccess.on_connect) RESTaccess.socketIO.on('disconnect', RESTaccess.on_close) RESTaccess.bearer_access_token = RESTaccess.create_bearer_token(RESTaccess.ACCESS_TOKEN, RESTaccess.socketIO._engineIO_session.id) # Create the FXCM market price streaming class # making sure to provide authentication commands prices = StreamingForexPrices(RESTaccess, instrument, events) # Create the portfolio object that will be used to # compare the OANDA positions with the local, to # ensure backtesting integrity. portfolio = Portfolio(prices, events, backtest = False, equity=1000000.0) # Create the execution handler making sure to # provide authentication commands execution = Execution(RESTaccess) # Create the strategy/signal generator, passing the # instrument, quantity of units and the events queue #strategy = TestRandomStrategy(instrument, events) strategy = MovingAverageCrossStrategy(instrument,events) #strategy = NewsDrivenStrategy(instrument,events) # Create two separate threads: One for the trading loop # and another for the market price streaming class trade_thread = threading.Thread(target=trade, args=(events, strategy, portfolio, execution, heartbeat)) price_thread = threading.Thread(target=prices.stream_to_queue, args=[]) # Start both threads logger.info("Starting trading thread") trade_thread.start() logger.info("Starting price streaming thread")
from tokenize import tokenize from execution import Execution import errors import sys infile = open('test.tw') print("Reading File...") root = Execution(None) try: lines = tokenize(infile, root) except errors.ParsingException as e: print("Error parsing line %d:\n>>> %s\n%s" % (e.lnum, e.line.strip(), str(e))) sys.exit(1) print("Executing Timestream...") root.run()
longQueue = strategy.doQueue(longQueue,strategySettings["longQueuePeriod"],row) # add current price to queue, along with stats #CHECK OPEN POSITIONS tradeOpen = strategy.checkOpen(connection.positions()) print "tradeOpen: ", tradeOpen # 2.A: STRATEGY: signal = strategy.maCrossAnticipate(row, priceQueue, longQueue, backtestSettings, tradeOpen) # check for buy/sell signals print signal["signal"] print connection.orders() if signal["signal"] and not tradeOpen and not connection.orders(): #event = tradeEvent("EUR_USD", 100000, signal["signal"], signal["stopLoss"], signal["takeProfit"]) threeMinutes = dt.utcnow() + datetime.timedelta(minutes=3) event = tradeEventLimit("EUR_USD", 100000, signal["signal"], signal["stopLoss"], signal["takeProfit"],signal["tradePrice"],threeMinutes.isoformat("T"),signal["upperBound"],signal["lowerBound"]) try: # PREPARE TRADE EXECUTION execution = Execution(API_DOMAIN, ACCESS_TOKEN, ACCOUNT_ID) execute = execution.execute_order(event) print execute except Exception, e: print "there was an error!\n" print repr(e) print str(e) else: pass time.sleep(60) #print " *** LIVE TRADING ***" # live trading