def crypto_tokens():
""" Crypto currency tokens """
try:
with open('crypto.csv', 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
positions = [Position(symbol=row[0], quantity=row[1])
for row in reader]
return Portfolio(positions)
except IOError:
return Portfolio()
def portfolio():
""" Stock market portfolio """
try:
with open('portfolio.csv', 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
positions = [Position(symbol=row[0], quantity=row[2])
for row in reader ]
return Portfolio(positions)
except IOError as err:
return Portfolio()
def portfolio():
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server()
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)
service = build('sheets', 'v4', credentials=creds)
# Call the Sheets API
sheet = service.spreadsheets()
result = sheet.values().get(spreadsheetId=SPREADSHEET_ID,
range=RANGE).execute()
values = result.get('values', [])
positions = [
Position(symbol=row[0], quantity=float(scrub(row[2])))
for row in values if len(row) > 1
]
return Portfolio(positions)
def create_portfolio(payload):
body = request.get_json()
portfolio_name = body.get('portfolio_name', None)
portfolio_compositions = body.get('portfolio_compositions', None)
# check if portfolio compositions sum up to 100 %
total_weight = 0
for portfolio_composition in portfolio_compositions:
total_weight += portfolio_composition['weight']
if total_weight != 100:
abort(422)
portfolio = Portfolio(name=portfolio_name)
for portfolio_composition in portfolio_compositions:
composition = PortfolioComposition(
security_id=portfolio_composition['security_id'],
weight=portfolio_composition['weight'])
composition.portfolio = portfolio
composition.insert()
return jsonify({
'success': True,
'portfolio_id': portfolio.id,
'portfolio_name': portfolio.name,
})
def add_user():
name = request.form['username']
psw = request.form['passw']
con_psw = request.form['conf_pass']
user_with_that_name = User.query.filter_by(username=name).count()
if user_with_that_name > 0:
flash("That name is already in use, come up with another", "negative")
return render_template('sign-up-form.html')
elif len(psw) < 6 or len(psw) > 20:
flash("Passwords must be at least 6 chars long, 20 at most.",
"negative")
return render_template('sign-up-form.html', username=name)
elif psw != con_psw:
flash("Passwords didn't match!!", "negative")
return render_template('sign-up-form.html', username=name)
else:
new_user = User(name, psw)
db.session.add(new_user)
db.session.commit()
# need to do this AFTER new_user commited so id is generated
new_user_portfolio = Portfolio(holder_id=new_user.id)
#start a schedule for user's updates (jobs) to be added to
skedge_start_with_check()
db.session.add(new_user_portfolio)
db.session.commit()
session['username'] = new_user.username
flash("Logged IN!", "positive")
return render_template('edit.html', username=session['username'])
def get_portfolios(client, acc_names) -> [Portfolio]:
portfolios = list()
for acc in acc_names.keys():
portfolio = Portfolio(acc, acc_names[acc])
portfolio.df = get_df(client, acc)
portfolios.append(portfolio)
return portfolios
def test_total_expected_earnings(self):
position_1 = Position(stock=Stock('ticker', 'name', 20, 30),
quantity=2)
position_2 = Position(stock=Stock('ticker', 'name', 20, 40),
quantity=2)
portfolio = Portfolio(position_1, position_2)
self.assertEqual(Decimal('1.5'), portfolio.total_expected_earnings)
def add_portfolio():
if request.method == 'POST':
portfolio = session.query(Portfolio).all()
target = os.path.join(app.config['BASE_DIR'], 'static/image')
if not os.path.isdir(target):
os.mkdir(target)
for file in request.files.getlist("image"):
filename = file.filename
destination = "/".join([target, filename])
image = '../static/image/' + filename
file.save(destination)
# Creating a books object to add to the databse.
image = '../static/image/' + request.form['image']
port = Portfolio(title=request.form['title'],
skills_used=request.form['skills_used'],
demo_url=request.form['demo_url'],
github_url=request.form['github_url'],
description=request.form['description'],
client=request.form['client'],
created_month=request.form['created_month'],
created_year=request.form['created_year'],
service=request.form['service'],
image=image)
session.add(port)
session.commit()
return redirect(url_for('portfolio.portfolio'))
else:
return render_template('modifyPortfolio.html', type='add')
def snapshot(save=True):
stocks = polling()
from models import Portfolio
portfolio = Portfolio(stocks)
if save:
portfolio.save()
return portfolio
def mutate(self, info, user_data=None):
# NOTE: Netlify creates the account regardless of this response
portfolio = Portfolio()
settings = Settings()
metrics = UserMetrics()
try:
user = User.objects.get(pk=user_data.email)
# If no query error, then either the user exists or
# user variable becomes None. In both cases the response fails.
return CreateUserMutation(user=None, success=False)
except Exception as e: # email not taken
if "matching query does not exist" not in str(e):
# unexpected error during query
return CreateUserMutation(user=None, success=False)
user = User(name=user_data.name,
bio=user_data.bio,
email=user_data.email,
password=user_data.password,
profile_pic=user_data.profile_pic,
metrics=metrics,
achievements=[],
personal_portfolio=portfolio,
groups=[],
settings=settings)
checkAchievements(user)
user.save()
return CreateUserMutation(user=user, success=True)
def update_portfolio_model(self, portfolio):
with create_session() as session:
portfolio_model = Portfolio(btc_value=portfolio)
account_model = session.query(ExchangeAccount).filter_by(
id=self.account_model_id).first()
account_model.portfolio.append(portfolio_model)
session.add(account_model)
session.commit()
def init_db():
art = [
Artwork(title="Street Art", description="A true masterpiece", location=[7,80]),
Artwork(title="Hidden Subway Mural", description="Far side of the subway station has a double walled mural.", location=[10,132]),
Artwork(title="Blue Bridge", description="Neon blue tentacles of paint wind up the struts of the bridge", location=[0,0], tags=["amazing"]),
Artwork(title="Artistic Underpass", description="Bridge ceiling covered in art", location=[0,0], tags=["surreal", "amazing"]),
Artwork(title="Fire Wall", description="Tongues of flame comemorate the historic fire of this district", tags=["sad", "historic", "amazing"], location=[0,0]),
Artwork(title="Street Corner Fresco", description="This popular street has a decorative fresco spilling out of the alley behind a popular restaurant", tags=["amazing", "unreal"], location=[0,0])
]
for a in art:
a.save()
portfolios = [
Portfolio(artworks=[art[0], art[1]]),
Portfolio(artworks=[art[2], art[4]]),
Portfolio(artworks=[art[1], art[2], art[3]]),
Portfolio(artworks=[art[3], art[5]]),
]
for p in portfolios:
p.save()
users = [
User(name="Grant", portfolio=portfolios[0], bio="Love me some AI and maybe web dev."),
User(name="Braden", portfolio=portfolios[1], bio="Spending some time on CSC 400."),
User(name="Kyle", portfolio=portfolios[2], bio="Fitness, meditation and good books."),
User(name="John", portfolio=portfolios[3], bio="Looking around for some art. Wasn't satisfied with my dope Windows Vista wallpaper.")
]
for user in users:
user.save()
achievements = [
Achievement(title="Noob", description="You signed up for the service!", points=10)
]
for a in achievements:
a.save()
for user in users:
user.achievements.append(achievements[0])
for user, portfolio in zip(users, portfolios):
portfolio.owner = user
for portfolio in portfolios:
portfolio.save()
def portfolio(portfolio_id):
"""Message of /port_*id* command"""
port = Portfolio(portfolio_id)
if port.count_papers() > 0:
message = 'Your papers\n'
port.current_prices()
for paper in port.papers:
message += f'{paper}\n' \
f'{paper.change()} {paper.currency} ({paper.percent()}%) \n' \
f'{paper.market()}\n\n'
return message
else:
return "No papers"
def portfolio_alloc(raw_data, candidate_list, candidate_pick_num,
user_selectFund, user_selectFund_weights,
extraPortfolio_ratio, ivt_loop_num):
minimum_weight = 0.1
candidate_combs = list(combinations(candidate_list, candidate_pick_num))
weight_alloc_combs = weight_alloc(candidate_pick_num,
(1 - extraPortfolio_ratio) * 100, 3, 3)
new_weight_alloc_combs = []
for weight_comb in weight_alloc_combs:
if min(weight_comb) > minimum_weight:
new_weight_alloc_combs.append(weight_comb)
# print(new_weight_alloc_combs)
portfolio_alloc_list = []
if len(new_weight_alloc_combs) > 0:
for candidate_comb in candidate_combs:
# print(candidate_comb)
for weight_alloc_comb in new_weight_alloc_combs:
new_return_list = []
weight_alloc_comb_perms = set(
list(permutations(weight_alloc_comb)))
for weight_alloc_comb_perm in weight_alloc_comb_perms:
final_candidate_comb = candidate_comb + tuple(
user_selectFund)
final_weight_alloc_comb_perm = weight_alloc_comb_perm + tuple(
user_selectFund_weights)
new_return_list = newFund_return(
raw_data, final_candidate_comb,
final_weight_alloc_comb_perm)
q = index_q(new_return_list, ivt_loop_num)
portfolio_alloc_list.append([
q, final_candidate_comb, final_weight_alloc_comb_perm
])
# check no recommend
if len(portfolio_alloc_list) == 0:
return None
temp_min = min(portfolio_alloc_list)
co_risk = cal_co_risk(temp_min[1], temp_min[2], raw_data, "downside")
co_return = cal_co_return(temp_min[1], temp_min[2], raw_data)
# print(co_risk,co_return)
min_portfolio = Portfolio(temp_min[0], temp_min[1], temp_min[2],
co_return / co_risk)
return min_portfolio
def mutate(self, info, group_data=None):
user = UpdateUserMutation.getUser(group_data.member_to_add)
group_portfolio = Portfolio()
group = Group(name=group_data.name,
bio=group_data.bio,
members=[user],
metrics=GroupMetrics(artwork_count=0, member_count=1),
group_portfolio=group_portfolio,
chat=[])
group.save()
user.groups.append(group)
user.save()
return CreateGroupMutation(group=group)
def buy(request):
if not request.session.get('id'):
return redirect('login')
if request.method == 'POST':
if not request.POST.get('symbol'):
return apology('Symbol field cannot be empty')
if not request.POST.get('quantity'):
return apology('Quantity field cannot be empty')
symbol = request.POST.get('symbol').upper()
quantity = int(request.POST.get('quantity'))
stock_info = lookup(symbol)
if not stock_info:
return apology("No such symbol exists")
user_info = Users.objects.filter(id=request.session.get('id'))
if not user_info:
return apology("Your session is invalid")
available_cash = user_info[0].cash
if available_cash >= quantity * stock_info.get('price'):
user_portfolio = Portfolio.objects.filter(
id=request.session.get('id')).filter(symbol=symbol)
if user_portfolio:
user_portfolio[0].price += stock_info.get('price') * quantity
user_portfolio[0].quantity += quantity
user_portfolio[0].save()
else:
user_portfolio = Portfolio(
id=request.session.get('id'),
symbol=symbol,
price=stock_info.get('price') * quantity,
quantity=quantity,
stock_name=stock_info.get('name'),
)
user_portfolio.save()
user_info[0].cash -= quantity * stock_info.get('price') * quantity
user_info[0].save()
return redirect('index')
else:
return apology("You do not have enough cash")
else:
return render(request, 'app/buy.html')
def post(self):
print('Adding new Portfolio')
#app.logger.info(f'Received : {request.json}')
#app.logger.info(f'Received : {request.get_json()}')
# find the user id from JWT token
logged_user_id = get_jwt_identity()
new_portfolio = Portfolio(
id=request.json["id"],
portfolio_title=request.json["portfolio_title"],
portfolio_desc=request.json["portfolio_desc"],
date_created=request.json["date_created"],
date_updated=request.json["date_updated"],
user_id=logged_user_id #request.json["user_id"]
)
db.session.add(new_portfolio)
db.session.commit()
return stockschema.dump([new_portfolio])
def save_portfolio(self, portfolio, name, date):
#NOTE ndict annoying stuff
session = self.manager.db.Session()
# Cleaning
session.execute(
"delete from Positions where Positions.PortfolioName = '{}'".
format(name))
#session.execute("delete from Portfolios where Portfolios.Name = '{}'".format(name))
pf_object = Portfolio(name=name,
date=date.strftime(format='%Y-%m-%d %H:%M'),
startdate=portfolio.start_date,
cash=portfolio.cash,
startingcash=portfolio.starting_cash,
returns=portfolio.returns,
capital=portfolio.capital_used,
pnl=portfolio.pnl,
portvalue=portfolio.portfolio_value,
posvalue=portfolio.positions_value)
positions = json.loads(
str(portfolio.positions).replace('Position(',
'').replace(')',
'').replace("'", '"'))
assert isinstance(positions, dict)
#FIXME In remote mode with lot of portfolios: make it crash !
for ticker in positions:
positions[ticker]['name'] = name
positions[ticker]['date'] = date
session.add(Position(**positions[ticker]))
#NOTE bug: 'not list-like object', but not an issue ?
#pf_object.Positions = Position(**positions[ticker])
#name=name,
#ticker='pouet',
#amount=0,
#last_sale_price=0,
#cost_basis=0)
session.add(pf_object)
session.commit()
session.close()
def get_stock_values(portfolio):
query = {
'symbols': ",".join(portfolio.tickers),
'types': 'quote,news,chart',
'range': '1m',
'last': 5
}
url = HOSTNAME +\
'/stock/market/batch?' +\
query_s(query)
resp = requests.get(url)
params = resp.json()
return Portfolio([
Position(symbol=vals['quote']['symbol'],
price=vals["quote"]["latestPrice"],
quantity=portfolio[ticker].quantity)
for ticker, vals in params.iteritems()
])
def update_account_portfolio(self):
with create_session() as session:
timestamp = datetime.utcnow()
account = session.query(AccountModel).filter_by(
api_key=self.api_key).first()
if not account:
raise ValueError("account not found")
assets = account.my_assets
portfolio_in_eth = get_portfolio_in_eth(assets)
default_quotes = portfolio_in_eth['default_quotes']
quote_dict = {}
for default_quote in default_quotes:
quote_dict[default_quote['symbol']] = default_quote['price']
for asset_portfolio in portfolio_in_eth['portfolio']:
asset = [
asset for asset in assets
if asset.name == asset_portfolio['symbol']
]
if asset:
asset = asset[0]
asset.eth_value = asset_portfolio['eth_cost']
asset.quote_price = asset_portfolio['price']
asset.pair_name = asset_portfolio['pair_name']
asset.timestamp = timestamp #last time the asset eth value was update
session.add(asset)
port = Portfolio(account=account,
asset=asset,
asset_name=asset.name,
total_value=asset.free + asset.fixed,
eth_value=asset_portfolio['eth_cost'],
quote_price=asset_portfolio['price'],
pair_name=asset_portfolio['pair_name'],
timestamp=timestamp,
eth_btc_quote=quote_dict['ETHBTC'],
bnb_eth_quote=quote_dict['BNBETH'],
eth_usdt_quote=quote_dict['ETHUSDT'])
session.add(port)
session.commit()
def generate_demo_csv():
position_a = Position(quantity=2,
ticker='AA',
name='A & A',
current_value=20,
expected_value=30)
position_b = Position(quantity=3,
ticker='BB',
name='B & B',
current_value=30,
expected_value=40)
position_c = Position(quantity=4,
ticker='CC',
name='C & C',
current_value=40,
expected_value=50)
position_d = Position(quantity=5,
ticker='DD',
name='D & D',
current_value=50,
expected_value=60)
portfolio = Portfolio(position_a, position_b, position_c, position_d)
portfolio.write_to_file(os.path.join(PORTFOLIO_DIR, 'demo.csv'))
def portfolio_add_update():
form = PortoForm(request.form)
if form.validate_on_submit():
result = {'iserror': False}
if not form.portfolio_id.data:
user = User.query.filter_by(username=session['username']).first()
if user is not None:
user.portfolio.append(
Portfolio(title=form.title.data,
description=form.description.data,
tags=form.tags.data))
db.session.commit()
result['savedsuccess'] = True
else:
result['savedsuccess'] = False
portfolio = Portfolio.query.get(
get_portofolio(form.portfolio_id.data))
form.populate_obj(portfolio)
result['savedsuccess'] = True
return json.dumps(result)
form.errors['iserror'] = True
return json.dumps(form.errors)
def buy_stock(user_id):
user = User.query.filter_by(id=user_id).first()
if not user:
return jsonify({"Message": "No user found"})
request_data = request.get_json()
stock = Portfolio.query.filter_by(
companyName=request_data["companyName"]).filter_by(
user_id=user_id).first()
x = datetime.datetime.now()
new_transaction = Transaction(user_id=user_id,
transactionName="buy",
symbol=request_data["symbol"],
price=request_data["price"],
shares=request_data["shares"],
date=str(x.strftime("%x")))
if user.buying_power < request_data["price"] * request_data["shares"]:
return jsonify({"message": "insufficient funds"})
if stock:
user.buying_power -= request_data["price"] * request_data["shares"]
stock.shares += request_data["shares"]
db.session.add(new_transaction)
db.session.add(stock)
db.session.commit()
return jsonify({"Message": "shares updated"})
stock_added = Portfolio(symbol=request_data["symbol"],
companyName=request_data["companyName"],
price=request_data["price"],
shares=request_data["shares"],
user_id=user_id)
user.buying_power -= request_data["price"] * request_data["shares"]
db.session.add(new_transaction)
db.session.add(stock_added)
db.session.commit()
return jsonify({"message": "new stock created "}), 200
def test(self):
results = iex.get_stock_values(Portfolio(map(lambda ticker: Position(symbol=ticker, quantity=1), ['aapl', 'amzn', 'gpc'])))
assert results[0].symbol == 'AAPL'
def fetch_portfolios(user):
"""Fetch portfolios by user.user_id"""
data = query.fetch('portfolios', ['id'], holder_id=user.id)
return [Portfolio(x['id']) for x in data]
def recommend(user_input, line_bot_api, user_id):
#### User Input ####
extraPortfolio_ratio = user_input.extraPortfolio_ratio
user_selectFunds = user_input.user_selectFunds
user_selectFund_weights = user_input.user_selectFund_weights
user_recommend_num = user_input.user_recommend_num
#### Transform user_selectFund_weights to user_portfolio_weights_arr ####
## Description: Multiply (1-extraPortfolio_ratio) to user_selectFund_weights
user_portfolio_weights_arr = (
1 - extraPortfolio_ratio) * np.array(user_selectFund_weights)
user_portfolio_weights = user_portfolio_weights_arr.tolist()
#### Get the Funds' data ####
## Note: Has removed the funds that were closed or have few data
message = TextSendMessage(text="讀取基金資料\U0010005E...")
line_bot_api.push_message(user_id, message)
df = readcsv.read_df(FUNDS_PREPROC_CSV_NAME)
## Check if user_selectFunds are in df.columns
for fund in user_selectFunds:
if not (fund in df.columns):
return None, None
#### Get the original_cluster_dict information ####
original_cluster_dict = {}
with open('original_cluster_dict' + '.pkl', 'rb') as f:
original_cluster_dict = pickle.load(f)
#### Get the bestFund_dict information ####
bestFund_dict = {}
new_bestFund_dict = {}
with open('bestFund_dict' + '.pkl', 'rb') as f:
bestFund_dict = pickle.load(f)
#### Get the bestFund_dict excluding the groups that user_selectFund was in ####
message = TextSendMessage(text="Pre-processing\U0010005E...")
line_bot_api.push_message(user_id, message)
new_bestFund_dict = calculate.cluster_preproc(original_cluster_dict,
bestFund_dict,
user_selectFunds)
#### Pick the top 5 of bestFunds ####
candidate_list = calculate.pick_candidate(new_bestFund_dict, candidate_num)
#### Calculate the orginal protfolio ####
portfolio_list = []
new_returns = calculate.newFund_return(df, user_selectFunds,
user_selectFund_weights)
orginal_q = calculate.index_q(new_returns, ivt_loop_num)
co_risk = calculate.cal_co_risk(user_selectFunds, user_selectFund_weights,
df, "downside")
co_return = calculate.cal_co_return(user_selectFunds,
user_selectFund_weights, df)
# print(co_risk,co_return)
orginal_protfolio = Portfolio(orginal_q, user_selectFunds,
user_selectFund_weights, co_return / co_risk)
portfolio_list.append(orginal_protfolio)
#### Calculate protfolios with extra funds ####
message = TextSendMessage(text="計算中(這可能會花點時間\U0010005E)...")
line_bot_api.push_message(user_id, message)
for i in range(1, user_recommend_num + 1):
portfolio = calculate.portfolio_alloc(df, candidate_list, i,
user_selectFunds,
user_portfolio_weights,
extraPortfolio_ratio,
ivt_loop_num)
if portfolio != None:
portfolio_list.append(portfolio)
recommend_portfolio = min(portfolio_list, key=attrgetter('index_q'))
number_to_name = {}
with open('label2name_dict' + '.pkl', 'rb') as f:
number_to_name = pickle.load(f)
temp_labels = []
for item in orginal_protfolio.labels:
temp_labels.append(
number_to_name.get(item, "Unkown name") + "(" + item + ")")
orginal_protfolio.labels = temp_labels
# ori = rec
if len(orginal_protfolio.labels) == len(recommend_portfolio.labels):
return orginal_protfolio, recommend_portfolio
temp_labels = []
for item in recommend_portfolio.labels:
temp_labels.append(
number_to_name.get(item, "Unkown name") + "(" + item + ")")
recommend_portfolio.labels = temp_labels
return orginal_protfolio, recommend_portfolio
def post(self):
newPortfolio = Portfolio()
newPortfolio.title = self.request.get("title")
newPortfolio.description = self.request.get("description")
newPortfolio.put()
self.render('frontend/portfolio-createlist.html')
from misc import dp, bot
from models import Portfolio
import handlers.keyboard as kb
# Класс FSM чтобы сохранять список состояний
class PortfolioFSM(StatesGroup):
portfolio = State()
broker = State()
margin = State()
cancel_b = types.ReplyKeyboardMarkup(resize_keyboard=True).add(kb.cancel_kb)
# New instance of Portfolio() class to save data
new_port = Portfolio()
@dp.message_handler(commands=['newportfolio'])
async def new_portfolio(message: types.Message):
await PortfolioFSM.portfolio.set()
await bot.send_message(message.chat.id,
"Enter name of portfolio",
reply_markup=cancel_b)
# You can use state '*' if you need to handle all states
@dp.message_handler(state='*', commands='cancel')
@dp.message_handler(Text(equals='cancel', ignore_case=True), state='*')
async def cancel_handler(message: types.Message, state: FSMContext):
"""Allow user to cancel any action"""
price_hover = p.select(dict(type=HoverTool))
# Choose, which glyphs are active by glyph name
price_hover.names = ["price"]
# Creating tooltips
price_hover.tooltips = [("Datetime", "@Date{%Y-%m-%d}"),
("Open", "@Open{$0,0.00}"),
("Close", "@Close{$0,0.00}"),
("Volume", "@Volume{($ 0.00 a)}")]
price_hover.formatters = {"Date": 'datetime'}
return p
stock = ColumnDataSource(
data=dict(Date=[], Open=[], Close=[], High=[], Low=[], index=[]))
myPortfolio = Portfolio(['CSCO', 'DTE.DE', 'NOK'], [1, 1, 2], [1, 1, 1],
[1, 1, 1])
sample_df = pd.DataFrame(data=myPortfolio.share_data['CSCO']).dropna()
sample_df.reset_index(inplace=True)
stock.data = stock.from_df(sample_df)
elements = list()
p_stock = plot_stock_price(stock)
elements.append(p_stock)
curdoc().add_root(column(elements))
curdoc().title = 'CSCO Data'
