def get_matrix_containing_position(position: Position) -> Matrix:
query = {
"x_start": {
"$lte": position.x
},
"x_end": {
"$gte": position.x
},
"y_start": {
"$lte": position.y
},
"y_end": {
"$gte": position.y
}
}
matrix = matrices.find_one(query)
if matrix is None:
return None
return Matrix(matrix["id"], matrix["x_start"], matrix["x_end"],
matrix["y_start"], matrix["y_end"], [
EntryPosition(Position(entry["x"], entry["y"]),
entry["command_index"])
for entry in matrix["entry_positions"]
])
def create_position(stv, vote, row):
for key, value in row.items():
if check_if_position_vote(key):
position_part = key.split('[')
position_name = position_part[0].strip()
if position_name not in vote.positions:
role = match_role(stv, position_name)
if role is None:
raise Exception("Role not found, although is was of a \
valid format.")
position = Position(role)
vote.positions[position_name] = position
else:
position = vote.positions[position_name]
position_candidate = position_part[1].split(']')[0].strip()
candidate_vote = CandidateVote(position_candidate)
rank = get_valid_vote_value(value)
if rank is not None:
candidate_vote.value = rank
position.candidate_votes.append(candidate_vote)
def currentOpen(self, accountId):
"""
(self: Positions) -> [Position]
"""
condition = {'$and': [{'account_id': accountId}, {'status': 'open'}]}
positions = self.collection.find(condition).sort('timestamp', -1)
positions = [Position.fromDict(p) for p in positions]
#return Positions.filterOpen(positions)
return positions
def get_new_position(command: str, position: Position) -> Position:
new_position = Position(position.x, position.y)
if command == "N":
new_position.y += 1
if command == "S":
new_position.y -= 1
if command == "E":
new_position.x += 1
if command == "O":
new_position.x -= 1
return new_position
def one(self, accountId, timestamp=None):
"""
(self: Positions, accountId: float?) -> Position
"""
conditions = [{'account_id': accountId}]
if timestamp is not None:
conditions.append({'timestamp': timestamp})
conditions = {'$and': conditions}
position = self.collection.find_one(conditions)
if position is not None:
position = Position.fromDict(position)
return position
def postBtctaiPositions(accountId, timestamp):
identity = flask_jwt.get_jwt_identity()
if accountId != identity:
flask.abort(403)
obj = flask.request.get_json()
position = modelPositions.one(accountId, timestamp=float(timestamp))
position = position.toDict()
obj = {**position, **obj}
position = Position.fromDict(obj)
position = modelPositions.save(position, accountId=accountId)
obj = position.toDict()
return flask.jsonify(obj)
def all(self, accountId, before=None, count=None):
"""
(self: Positions, accountId: str, before: float?, count: int?) -> [Position]
"""
conditions = [{'account_id': accountId}]
if before is not None:
conditions.append({'timestamp': {'$lt': before}})
conditions = {'$and': conditions}
positions = self.collection.find(conditions).sort('timestamp', -1)
if count is not None:
positions = positions.limit(count)
positions = [Position.fromDict(p) for p in positions]
return positions
def addpoi():
data = json.load(open('projects/' + project + '/pois.json'))
graph = Graph(project, auto_connect=False)
level = int(request.form.get('level'))
x = int(request.form.get('x'))
y = int(request.form.get('y'))
name = request.form.get('name')
room = graph.get_room(Position(level, x, y))
if room is None:
return json.dumps({'success': False})
data[name] = {'level': level, 'x': x, 'y': y}
json.dump(data,
open('projects/' + project + '/pois.json', 'w'),
indent=4,
sort_keys=True)
return 'ok'
def init() -> None:
global total_pokemons_hunted
total_pokemons_hunted = 0
db_service.init()
global cache_matrices
cache_matrices = []
global matrix_count
matrix_count = 0
global current_position
current_position = None
global current_matrix
current_matrix = None
global input_index
input_index = 0
set_position(Position(0, 0))
set_initial_matrix()
def openPosition(self, lot, traderFun):
"""
(self: TradeExecutor, lot: float) -> Trade, Position
"""
models = self.models
try:
position = traderFun(lot)
self.logger.debug('Result of opening position is, position={position}.'
.format(position=position))
if position is None:
return None, None
except Exception as e:
self.logger.error(('Unexpected error occured in opening position, e={e}'
.format(e=e)))
return None, None
now = datetime.datetime.now()
trade_ = Trade(now, position)
self.logger.debug('Saving new trade, {t}.'.format(t=trade_))
trade = models.Trades.save(trade_, accountId=self.accountId)
position_ = Position(now, Position.StatusOpen, [position])
self.logger.debug('Saving new position, {p}.'.format(p=position_))
position = models.Positions.save(position_, accountId=self.accountId)
return trade, position
start_date = utils.date_to_str(hist.index[0].date())
today = utils.date_to_str(datetime.date.today())
close = list(hist['Close'])
days_list = [i for i in range(len(close))]
df = pd.DataFrame({"Price": close, "Days": days_list})
plot = sb.lineplot(x="Days", y="Price", data=df)
plot.set(xlabel=("{start} to {today} ~ {days} days"
).format(start=utils.date_concat(start_date),
today=utils.date_concat(today),
days=days))
plot.set(ylabel=str(ticker_obj.info['symbol'] + " Price"))
plt.show()
return
# WORKSPACE
amd_pos = Position(amd)
aapl_pos = Position(yf.Ticker("AAPL"))
aapl_pos.add_position(100, 450)
aapl_pos.add_position(200, 420)
sample_date_future = datetime.date(2020, 10, 16)
sample_date_future_2 = datetime.date(2020, 9, 11)
bought = Option(fb, sample_date_future, 290, True)
print(bought)
window_vol = master_volatility.iloc[vol_index].dropna()
window_vol = window_vol[(window_vol != 0)]
window_vol = window_vol.drop("Date")
window_vol.sort(ascending=True)
##
# Get Deciles
##
top_decile = window_vol[0:int(math.ceil(len(window_vol) / 10.0))]
bottom_decile = window_vol[len(window_vol) - int(math.ceil(len(window_vol) / 10.0)):]
##
# Portfolio Manipulations
##
portfolio.reducePositionLives()
portfolio.calculateReturn(date, master_returns.iloc[t])
portfolio.liquidate()
portfolio.addPosition(Position(top_decile.index, bottom_decile.index, 1))
portfolioD1.reducePositionLives()
portfolioD1.calculateReturn(date, master_returns.iloc[t])
portfolioD1.liquidate()
portfolioD1.addPosition(Position(top_decile.index, [], 1))
portfolioD10.reducePositionLives()
portfolioD10.calculateReturn(date, master_returns.iloc[t])
portfolioD10.liquidate()
portfolioD10.addPosition(Position(bottom_decile.index, [], 1))
##
# SUMMARIZE RESULTS
def refresh_positions():
global ALL_POSITIONS
ALL_POSITIONS = []
for str in dbfunc.get_positions():
ALL_POSITIONS.append(
Position(str[0], str[2], str[1], str[3], str[4], str[6], str[5]))
## JQ4_top_decile = ranked_list[0:int(math.ceil(len(ranked_list) / 10.0))] JQ4_bottom_decile = ranked_list[len(ranked_list) - int(math.ceil(len(ranked_list) / 10.0)):] JQ4_bottom_decile = JQ4_bottom_decile[JQ4_bottom_decile < 0] ## # MEASURE PERFORMANCE FOR MONTH T (UPDATES DONE AT END OF YEAR) # LIQUIDATE DEAD POSITIONS # ADD POSITIONS ## print "Calculating Portfolio Returns and Liquidating Old Positions..." for portfolio in portfolios: portfolio.reducePositionLives() portfolio.calculateReturn(date, master_returns.iloc[t]) portfolio.liquidate() if portfolio.getName() == "J: 12-1M, K: 3": portfolio.addPosition(Position(JQ4_top_decile.index, JQ4_bottom_decile.index, 3)) elif portfolio.getName() == "J: 12-1M, K: 6": portfolio.addPosition(Position(JQ4_top_decile.index, JQ4_bottom_decile.index, 6)) elif portfolio.getName() == "J: 12-1M, K: 9": portfolio.addPosition(Position(JQ4_top_decile.index, JQ4_bottom_decile.index, 9)) elif portfolio.getName() == "J: 12-1M, K: 12": portfolio.addPosition(Position(JQ4_top_decile.index, JQ4_bottom_decile.index, 12)) ## # SUMMARIZE RESULTS ## results = DataFrame(portfolios[0].getPortfolioReturns().items(), columns=['Date', portfolios[0].getName()]) for i in range(1, len(portfolios)): inp = DataFrame(portfolios[i].getPortfolioReturns().items(), columns=['Date', portfolios[i].getName()]) results = merge(results, inp, how="left", on="Date")
JQ2_bottom_decile = JQ2_bottom_decile[JQ2_bottom_decile < 0]
JQ3_bottom_decile = JQ3_bottom_decile[JQ3_bottom_decile < 0]
JQ4_bottom_decile = JQ4_bottom_decile[JQ4_bottom_decile < 0]
##
# MEASURE PERFORMANCE FOR MONTH T (UPDATES DONE AT END OF YEAR)
# LIQUIDATE DEAD POSITIONS
# ADD POSITIONS
##
print "Calculating Portfolio Returns and Liquidating Old Positions..."
for portfolio in portfolios:
portfolio.reducePositionLives()
portfolio.calculateReturn(date, master_returns.iloc[t])
portfolio.liquidate()
if portfolio.getName() == "J: 3, K: 3":
portfolio.addPosition(
Position(JQ1_top_decile.index, JQ1_bottom_decile.index, 3))
elif portfolio.getName() == "J: 3, K: 6":
portfolio.addPosition(
Position(JQ1_top_decile.index, JQ1_bottom_decile.index, 6))
elif portfolio.getName() == "J: 3, K: 9":
portfolio.addPosition(
Position(JQ1_top_decile.index, JQ1_bottom_decile.index, 9))
elif portfolio.getName() == "J: 3, K: 12":
portfolio.addPosition(
Position(JQ1_top_decile.index, JQ1_bottom_decile.index, 12))
elif portfolio.getName() == "J: 6, K: 3":
portfolio.addPosition(
Position(JQ2_top_decile.index, JQ2_bottom_decile.index, 3))
elif portfolio.getName() == "J: 6, K: 6":
portfolio.addPosition(
Position(JQ2_top_decile.index, JQ2_bottom_decile.index, 6))