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)
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 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)
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 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 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 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 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 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 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;
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))
# 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")
import os
import sys
import time
import traceback
from threading import Thread
import itchat
from autoreply import MsgAutoReply
from execution import Execution
from keeponline import KeepOnline
from keywordlistener import KeywordListener
from revocation import Revocation
from signin import SignInMPS
exec_command = Execution()
rmsg = Revocation()
listener = KeywordListener()
signfunc = SignInMPS()
keeponline = KeepOnline()
reply = MsgAutoReply()
visitors = 4
visitor_wait = False
msglist = list()
# 解析消息，构造{id:xxx, msg:{}, visit:xxx}类型的消息，加入消息队列
@itchat.msg_register([
itchat.content.TEXT,
itchat.content.PICTURE,
from task import Tasks
import matplotlib.pyplot as plt
import sys
if len(sys.argv) != 5:
print("Usage : main.py start_pi_value end_pi_value start_φi_value end_φi_value")
sys.exit(4)
startPi = int(sys.argv[1])
endPi = int(sys.argv[2])
startφi = int(sys.argv[3])
endφi = int(sys.argv[4])
exe = Execution()
exe.create_Task(startPi,endPi,startφi,endφi)
exe.sort_pi()
exe.doc.write("start value of task pi: "+str(startPi)+", end value of task pi: "+str(endPi)+'\n')
exe.doc.write("start value of task φi: "+str(startφi)+", end value of task φi: "+str(endφi)+'\n')
exe.doc.write("--------------------------------------------------------------------------------------------------"+'\n')
task = Tasks()
exe.display_task()
exe.display_sortedTask()
exe.display_intervalle()
import json
import falcon
from execution import Execution
from termination import Termination
from propagation import Propagation
from addition import Addition
from deletion import Deletion
from getting_list import GettingList
import os
with open('dejima_config.json') as f:
dejima_config_dict = json.load(f)
peer_name = os.environ['PEER_NAME']
db_conn_dict={} # key: xid, value: database connection for each xid transaction.
child_peer_dict = {} # key: xid, value: set of child peers for each xid transaction.
app = falcon.API()
app.add_route("/post_transaction", Execution(peer_name, db_conn_dict, child_peer_dict, dejima_config_dict))
app.add_route("/add_student", Addition(peer_name, db_conn_dict, child_peer_dict, dejima_config_dict))
app.add_route("/delete_student", Deletion(peer_name, db_conn_dict, child_peer_dict, dejima_config_dict))
app.add_route("/get_student_list", GettingList(peer_name, db_conn_dict, child_peer_dict, dejima_config_dict))
app.add_route("/_propagate", Propagation(peer_name, db_conn_dict, child_peer_dict, dejima_config_dict))
app.add_route("/_terminate_transaction", Termination(db_conn_dict, child_peer_dict, dejima_config_dict))
if __name__ == "__main__":
from wsgiref import simple_server
httpd = simple_server.make_server("0.0.0.0", 8000, app)
httpd.serve_forever()
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
import numpy as np
import tensorflow as tf
from execution import Execution
execution = Execution()
execution.detect_vehicles('imgs/12697433.jpg')
def __init__(self, pkg_dir):
self.pkg_dir = pkg_dir
self.execution = Execution(self.pkg_dir)
from execution import Execution obj = Execution() obj.show_menu() obj.cart() obj.show_cart() obj.billing()
if __name__ == '__main__':
heartbeat = 0.5 # Half second
events = Queue.Queue()
# Trade 10000 units of EUR/USD
instrument = 'EUR_USD'
units = 10000
# 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 execution handler making sure to
# provide authentication commands
execution = Execution(STREAM_DOMAIN, ACCESS_TOKEN, ACCOUNT_ID)
# Create the strategy/signal generator, passing the
# instrument, quantity of units and the events queue
strategy = TestRandomStrategy(instrument, units, 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, execution))
price_thread = threading.Thread(target=prices.stream_to_queue, args=[])
# Start both threads
trade_thread.start()
price_thread.start()
if config.is_backTest == True:
try:
os.remove('bookKeepingstore.h5')
except:
pass
#
# # Create the strategy/signal generator, passing the
# # instrument, quantity of units and the events queue
strategy = TestStrategy(events)
bookKeep = bookKeeping(events, config)
# # Create the execution handler making sure to
# # provide authentication commands
execution = Execution(config)
#
## # 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, execution))
trade_thread = threading.Thread(target=trade,
args=(events, strategy, execution,
instruments, data, bookKeep))
# price_thread = threading.Thread(target=prices[0].stream_to_queue, args=[])
# Start both threads
trade_thread.start()
# price_thread.start()
#kwargs={}
#x=None
