{{ message }}
44 | {% endfor %}
45 | {% block content %}{% endblock %}
46 | 
12 |
13 | # Table of Contents
14 | - [Introduction](https://github.com/RamonWill/Data-App#Introduction)
15 | - [Features](https://github.com/RamonWill/Data-App#Features)
16 | - [How it Works](https://github.com/RamonWill/Data-App#Installation)
17 | - [Credits](https://github.com/RamonWill/Data-App#Credit)
18 | - [Video Demo](https://github.com/RamonWill/Data-App#Video-Demo)
19 | - [Screenshots](https://github.com/RamonWill/Data-App#Screenshots)
20 |
21 | # Introduction
22 | Prescient Finance allows users to create an unlimited number of portfolios/watchlists to test out their strategies, monitor potential performance, or to simply track certain sectors. Users have a choice of over 1500+ equities from 10 different countries.
23 |
24 | # Features
25 | Other features of Prescient Finance include:
26 | * Time-series Performance charts at a portfolio and security level
27 | * Daily unrealised P&L breakdowns of their positions
28 | * Perform CRUD operations on their portfolios
29 | * View the daily Holding Period Return on a portfolio
30 | * Statistical graphics to help visualise portfolio exposure.
31 |
32 | # How it Works
33 | After Registration and logging in, A user can create a portfolio. The user can then start adding securities to the portfolio and enter the economics of the trade. The site will then display the various features based on the information entered by the user. If the security does not yet have a prices stored in the database, an api call will be made to Alpha Vantage and the last 100 End of Day (EOD) prices will be stored to the database. EOD prices are updated before midnight on every weekday.
34 |
35 | # Credits
36 | A big thank you to the Flask community for designing an interesting and flexible Framework. I would also like to thank Alpha Vantage again for the easy access to a wide range of financial data. Finally, a special thanks to the Pandas/Numpy community, Miguel Grinberg and the SQL-Alchemy Community.
37 |
38 | * Disclaimer: This project is not valid financial tool. It is a project that I've created to help me learn more about Python. You should in no way use it to make investment decisions.
39 |
40 | # Video-Demo
41 | The image below will redirect you to the video demo on Youtube
42 | [
](https://www.youtube.com/watch?v=CpiltoZI94M)
43 |
44 |
45 |
46 | # Screenshots
47 | 
48 | 
49 |
50 | [forks-shield]: https://img.shields.io/github/forks/RamonWill/Data-App.svg?style=for-the-badge
51 | [forks-url]: https://github.com/RamonWill/Data-App/network/members
52 | [stars-shield]: https://img.shields.io/github/stars/RamonWill/Data-App.svg?style=for-the-badge
53 | [stars-url]: https://github.com/RamonWill/Data-App/stargazers
54 | [issues-shield]: https://img.shields.io/github/issues/RamonWill/Data-App.svg?style=for-the-badge
55 | [issues-url]: https://github.com/RamonWill/Data-App/issues
56 | [license-shield]: https://img.shields.io/github/license/RamonWill/Data-App.svg?style=for-the-badge
57 | [license-url]: https://github.com/RamonWill/Data-App/blob/master/LICENSE.txt
58 |
--------------------------------------------------------------------------------
/Prescient/database_tools/update_existing_prices.py:
--------------------------------------------------------------------------------
1 | import requests
2 | import pandas as pd
3 | from sqlalchemy import create_engine
4 | import mysql.connector
5 | import time
6 |
7 | AV_KEY = "" # Enter your alpha vantage api key here
8 | url = "https://www.alphavantage.co/query?"
9 |
10 |
11 | class Update_existing_prices(object):
12 |
13 | def __init__(self, ticker):
14 | self.ticker = ticker
15 | self.market_prices = None
16 | self._daily_market_prices()
17 |
18 | def _daily_market_prices(self):
19 | parameters = {"apikey": "AV_KEY",
20 | "function": "TIME_SERIES_DAILY",
21 | "symbol": self.ticker}
22 | response = requests.get(url, params=parameters)
23 | response_json = response.json()
24 | data = response_json['Time Series (Daily)']
25 |
26 | df = pd.DataFrame.from_dict(data,
27 | orient="index",
28 | columns=["4. close"])
29 | df = df.rename(columns={"4. close": "price"})
30 | df = df.reset_index()
31 | self.market_prices = df
32 |
33 | def _store_temp_table(self):
34 | # stores a temporary file to to the database
35 | engine = create_engine("mysql://root:E6#hK-rA5!tn@localhost/prescientpricesdb")
36 | # writes the dataframes to SQL
37 | # df = self.daily_market_prices()
38 | self.market_prices.to_sql("temptable",
39 | con=engine,
40 | if_exists="replace",
41 | index=False)
42 | print(f"Stored temptable for {self.ticker}")
43 |
44 | def update_new_prices(self):
45 | """ runs a SQL query that appends new prices to the database"""
46 | self._store_temp_table()
47 | mydb = mysql.connector.connect(host="localhost",
48 | user="root",
49 | passwd="E6#hK-rA5!tn",
50 | database="prescientpricesdb")
51 | c = mydb.cursor()
52 | query = f"""INSERT INTO `{self.ticker}` (`index`, `price`)
53 | SELECT t.`index`, t.`price`
54 | FROM temptable t
55 | WHERE NOT EXISTS
56 | (SELECT 1 FROM `{self.ticker}` t2
57 | WHERE t2.`index`=t.`index`
58 | AND t2.`price`=t.`price`)"""
59 | c.execute(query)
60 | mydb.commit()
61 | c.close()
62 | mydb.close()
63 | self._drop_table()
64 |
65 | def _drop_table(self):
66 | mydb = mysql.connector.connect(host="localhost",
67 | user="root",
68 | passwd="E6#hK-rA5!tn",
69 | database="prescientpricesdb")
70 | c = mydb.cursor()
71 | query = """DROP TABLE temptable"""
72 | c.execute(query)
73 | c.close()
74 | mydb.close()
75 |
76 |
77 | mydb = mysql.connector.connect(host="localhost",
78 | user="root",
79 | passwd="E6#hK-rA5!tn",
80 | database="prescientmaindb")
81 | cur = mydb.cursor(buffered=True)
82 | query = """SELECT DISTINCT ticker FROM watchlist_securities"""
83 | cur.execute(query)
84 |
85 | counter = 0
86 | for item in cur.fetchall():
87 | ticker = item[0].lower()
88 | Prices = Update_existing_prices(ticker)
89 | Prices.update_new_prices()
90 |
91 | # 5 API requests per minute; 500 API requests per day
92 | # After 5 requests delay for 60 seconds
93 | if counter % 5 == 0:
94 | time.sleep(60)
95 | counter += 1
96 | cur.close()
97 | mydb.close()
98 |
--------------------------------------------------------------------------------
/tests/test_auth.py:
--------------------------------------------------------------------------------
1 | import os
2 | import unittest
3 | import sys
4 |
5 | topdir = os.path.join(os.path.dirname(__file__), "..")
6 | sys.path.append(topdir)
7 |
8 | from Prescient import app, db
9 | from Prescient.config import basedir
10 |
11 |
12 | # Integration tests
13 | class AuthorisationTests(unittest.TestCase):
14 | def setUp(self): # sets up the database
15 | app.config["TESTING"] = True # tests for assertions or exceptions
16 | app.config["WTF_CSRF_ENABLED"] = False
17 | app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///' + \
18 | os.path.join(basedir,
19 | 'test.db')
20 | self.app = app.test_client() # this creates a test client for the app
21 | db.create_all()
22 |
23 | def tearDown(self): # removes the database
24 | db.session.remove()
25 | db.drop_all()
26 |
27 | # Helper methods to create dummy post requests and store to test database
28 | def register_user(self, username, password, confirm):
29 | credentials = dict(username=username,
30 | password=password,
31 | confirm=confirm)
32 | return self.app.post("auth/register",
33 | data=credentials,
34 | follow_redirects=True)
35 |
36 | def login_user(self, username, password):
37 | credentials = dict(username=username,
38 | password=password)
39 | return self.app.post("auth/login",
40 | data=credentials,
41 | follow_redirects=True)
42 |
43 | def logout_user(self):
44 | return self.app.get("auth/logout", follow_redirects=True)
45 |
46 | # tests
47 | def test_auth_urls(self):
48 | response_login = self.app.get("auth/login", follow_redirects=True)
49 | response_register = self.app.get("auth/register", follow_redirects=True)
50 | response_logout = self.app.get("auth/logout", follow_redirects=True)
51 | self.assertEqual(response_login.status_code, 200)
52 | self.assertEqual(response_register.status_code, 200)
53 | self.assertEqual(response_logout.status_code, 200)
54 |
55 | def test_valid_user_registration(self):
56 | response = self.register_user("RandomUser1!",
57 | "Testing123",
58 | "Testing123")
59 | self.assertIn(b"Your account has now been created!", response.data)
60 |
61 | def test_invalid_user_registration_wrong_confirm(self):
62 | response = self.register_user("RandomUser1!", "Testing13", "Testing31")
63 | self.assertIn(b"Passwords must match", response.data)
64 |
65 | def test_invalid_user_registration_duplicate_username(self):
66 | response = self.register_user("RandomUser2",
67 | "python99",
68 | "python99")
69 | response = self.register_user("RandomUser2",
70 | "python11",
71 | "python11")
72 | self.assertIn(b"That username is already registered.", response.data)
73 |
74 | def test_valid_login(self):
75 | self.register_user("RandomUser1!", "Testing123", "Testing123")
76 | response = self.login_user("RandomUser1!", "Testing123")
77 | self.assertIn(b"Welcome to Prescient Finance", response.data)
78 |
79 | def test_invalid_login_wrong_username(self):
80 | self.register_user("RandomUser1!", "Testing123", "Testing123")
81 | response = self.login_user("randomuser1!", "Testing123")
82 | self.assertNotIn(b"Welcome to Prescient Finance", response.data)
83 |
84 | def test_invalid_login_wrong_password(self):
85 | self.register_user("RandomUser1!", "Testing123", "Testing123")
86 | response = self.login_user("RandomUser1!", "Testing456")
87 | self.assertNotIn(b"Welcome to Prescient Finance", response.data)
88 |
89 | def test_logout(self):
90 | self.register_user("RandomUser1!", "Testing123", "Testing123")
91 | self.login_user("RandomUser1!", "Testing123")
92 | response = self.logout_user()
93 | self.assertIn(b"Sign In", response.data)
94 |
95 |
96 | if __name__ == "__main__":
97 | unittest.main()
98 |
--------------------------------------------------------------------------------
/Prescient/static/styles/dashboard-styles.css:
--------------------------------------------------------------------------------
1 | .main-heading{
2 | text-align: center;
3 | color: white;
4 | font-size: 30px;
5 | }
6 |
7 | a {
8 | text-decoration: none;
9 | }
10 |
11 | .change-links{
12 | font-size: 18px;
13 | color: #1e67fa;
14 | padding: 4px;
15 | transition: 0.3s
16 | }
17 |
18 | .change-links:hover{
19 | font-size: 20px;
20 | color: #1e67fa;
21 | font-weight: bolder;
22 | padding: 4px;
23 | transition: 0.3s;
24 | }
25 |
26 | table {
27 | width: 550px;
28 | border-collapse: collapse;
29 | overflow: hidden;
30 | box-shadow: 0 0 20px rgba(0, 0, 0, 0.0);
31 | border-radius: 5px;
32 | }
33 |
34 | td {
35 | padding: 15px;
36 | background-color: rgba(0, 0, 0, 0.1);
37 | color: #B3E5FC;
38 | }
39 |
40 | th {
41 | text-align: left;
42 | font-weight: bolder;
43 | padding: 15px;
44 | }
45 |
46 | .watchlist-rows{
47 | transition: 0.2s
48 | }
49 |
50 | .watchlist-rows:hover{
51 | background-color: #40888f;
52 | }
53 |
54 | thead {
55 | background-color: rgba(127, 64, 222, 0.3);
56 | color: white;
57 | border: 2px solid #B388FF;
58 | }
59 |
60 | tbody {
61 | background-color: rgba(0, 0, 0, 0.2);
62 | border: 2px solid #B3E5FC;
63 | }
64 |
65 | .main-wrapper{
66 | max-width: 100%;
67 | display: grid;
68 | grid-template-columns: repeat(3, 1fr);
69 | grid-template-rows: repeat(3, 1fr);
70 | grid-column-gap: 1px;
71 | grid-row-gap: 1px;
72 | }
73 |
74 | @media screen and (max-width: 1000px) {
75 | .main-wrapper{
76 | display: block;
77 | }
78 | }
79 |
80 | .summary-table {
81 | align-items: center;
82 | justify-content: center;
83 | padding: 2px;
84 | border: 1px solid grey;
85 | max-width:100vw;
86 | box-sizing:border-box;
87 | grid-column-start: 1;
88 | grid-column-end: 2;
89 | }
90 |
91 | .line-chart-container{
92 | align-items: center;
93 | justify-content: center;
94 | padding: 2px;
95 | border: 1px solid grey;
96 | max-width:100vw;
97 | box-sizing:border-box;
98 | overflow: hidden;
99 | grid-column-start: 2;
100 | grid-column-end: 4;
101 | grid-row-start: 1;
102 | grid-row-end: 2;
103 | }
104 |
105 | .pie-chart-container{
106 | align-items: center;
107 | justify-content: center;
108 | padding: 2px;
109 | border: 1px solid grey;
110 | max-width:100vw;
111 | overflow: hidden;
112 | box-sizing:border-box;
113 | grid-column-start: 1;
114 | grid-column-end: 2;
115 | grid-row-start: 2;
116 | grid-row-end: 3;
117 | }
118 |
119 | .bar-chart-container{
120 | align-items: center;
121 | justify-content: center;
122 | padding: 2px;
123 | border: 1px solid grey;
124 | max-width: 100vw;
125 | box-sizing:border-box;
126 | overflow: hidden;
127 | grid-column-start: 2;
128 | grid-column-end: 4;
129 | grid-row-start: 2;
130 | grid-row-end: 3;
131 | }
132 |
133 | .worldmap-container{
134 | align-items: center;
135 | justify-content: center;
136 | padding: 2px;
137 | border: 1px solid grey;
138 | max-width:100vw;
139 | box-sizing:border-box;
140 | overflow: hidden;
141 | grid-column-start: 1;
142 | grid-column-end: 4;
143 | grid-row-start: 3;
144 | grid-row-end: 4;
145 | }
146 |
147 | .watchlist-name-title{
148 | color: #6397ff;
149 | font-weight: bolder;
150 | font-size: 38px;
151 | }
152 | .watchlist-username-title{
153 | color: #9960cc;
154 | font-weight: bolder;
155 | font-size: 38px;
156 | }
157 |
158 | .overview-select{
159 | color:black;
160 | border-radius: 5px;
161 | border: 2px solid #7f40de;
162 | border-radius: 8px;
163 | padding: 5px;
164 | font-size: 14px;
165 | font-weight: bold;
166 | cursor: pointer;
167 | transition: 0.7s;
168 | }
169 |
170 | .overview-select:hover{
171 | background-color: #7f40de;
172 | color: white;
173 | transition: 0.7s;
174 | }
175 |
176 | .Welcome2{
177 | text-align: center;
178 | position: absolute;
179 | top: 50%;
180 | left: 50%;
181 | transform: translate(-50%, -50%);
182 | color: white;
183 | }
184 |
185 | .main-heading2{
186 | font-size: 30px;
187 | }
188 |
189 | .to-watchlist-link {
190 | text-decoration: none;
191 | list-style-type: none;
192 | }
193 |
194 | .to-watchlist-link a{
195 | transition: 0.3s;
196 | color: #43a1e8;
197 | border-bottom: #46eb7a 1px solid;
198 | }
199 |
200 | .to-watchlist-link a:hover{
201 | transition: 0.3s;
202 | font-weight: bold;
203 | border-bottom: #46eb7a 2px solid;
204 | }
205 |
--------------------------------------------------------------------------------
/Prescient/static/base_style.css:
--------------------------------------------------------------------------------
1 | *{
2 | margin: 0px;
3 | padding: 0px;
4 | box-sizing: border-box;
5 | }
6 |
7 | nav{
8 | display: flex;
9 | justify-content: space-around;
10 | align-items: center;
11 | min-height: 12vh;
12 | background-image: linear-gradient(135deg, #0b071f, #0F2027,#203A43);
13 | font-family: 'Ubuntu', sans-serif;
14 |
15 | }
16 | .nav-icons li{
17 | list-style: none;
18 | font-size: 20px;
19 | }
20 |
21 | .username{
22 | color: #BED2FA;
23 | font-size: 25px;
24 | }
25 |
26 | .nav-icons a{
27 | text-decoration: none;
28 | color: #1e67fa;
29 | transition: 0.3s;
30 | padding-top: 20px;
31 | padding-bottom: 20px;
32 | }
33 |
34 | .nav-icons a:hover{
35 | color: #94b7ff;
36 | font-size: 25px;
37 | }
38 |
39 | .nav-icons{
40 | display: flex;
41 | justify-content: space-around;
42 | text-decoration: none;
43 | width: 70%;
44 | letter-spacing: 1px;
45 | font-weight: bold;
46 | }
47 |
48 | .breaks{
49 | display: none;
50 | }
51 |
52 | .breaks div{
53 | width: 25px;
54 | height: 5px;
55 | background-color: #c7d5e8;
56 | margin: 2px;
57 | cursor: pointer;
58 | transition: all 0.4s ease
59 | }
60 |
61 | @media screen and (max-width:1024px) {
62 | .nav-icons{
63 | width: 60%;
64 | }
65 | }
66 |
67 | @media screen and (max-width:1000px) {
68 | body{
69 | overflow-x: hidden;
70 | }
71 | .nav-icons{
72 | position: absolute;
73 | left: 0px;
74 | height: 100vh;
75 | top: 12vh;
76 | background-image: linear-gradient(135deg, #0b071f, #0F2027,#203A43);
77 | display: flex;
78 | flex-direction: column;
79 | align-items: center;
80 | width: 30%;
81 | transform: translateX(-100%);
82 | transition: transform 0.5s ease-in;
83 | }
84 | .nav-icons li{
85 | opacity: 0;
86 | }
87 | .breaks{
88 | display: block;
89 | }
90 | }
91 |
92 | .nav-active{
93 | transform: translateX(0%);
94 | }
95 |
96 | @keyframes navLinkFade {
97 | from{
98 | opacity: 0;
99 | transform: translateX(-50px);
100 | }
101 | to{
102 | opacity: 1;
103 | transform: translateX(0px);
104 | }
105 | }
106 |
107 | .toggle .bk1{
108 | transform: rotate(-45deg) translate(-5px,5px);
109 | background-color: #91ACD2;
110 | }
111 |
112 | .toggle .bk2{
113 | opacity: 0;
114 | }
115 |
116 | .toggle .bk3{
117 | transform: rotate(+45deg) translate(-5px,-5px);
118 | background-color: #91ACD2;
119 | }
120 |
121 | .main-content {
122 | min-height: 100vh;
123 | padding-left: 10px;
124 | background-image: linear-gradient(135deg,#224080, #0F2027, #17323d, #17323d,#3b4a6b);
125 | font-family: 'Open Sans', sans-serif;
126 | color: white;
127 | transition: 1.3s ease;
128 | }
129 |
130 | .main-content-active{
131 | padding-left: 30%;
132 | transition: 0.45s ease;
133 | }
134 |
135 | /* width */
136 | ::-webkit-scrollbar {
137 | width: 13px;
138 | }
139 |
140 | /* Track */
141 | ::-webkit-scrollbar-track {
142 | background: #0F2027;
143 | }
144 |
145 | /* Handle */
146 | ::-webkit-scrollbar-thumb {
147 | background: #612f80;
148 | }
149 |
150 | /* Handle on hover */
151 | ::-webkit-scrollbar-thumb:hover {
152 | background: #45205c;
153 | }
154 |
155 | select {
156 | font-size: 13px;
157 | font-weight: 700;
158 | color: #444;
159 | line-height: 1.3;
160 | padding: .6em 1.4em .5em .8em;
161 | box-sizing: border-box;
162 | margin: 0;
163 | border: 1px solid #aaa;
164 | box-shadow: 0 1px 0 1px rgba(0,0,0,.04);
165 | border-radius: .5em;
166 | -moz-appearance: none;
167 | -webkit-appearance: none;
168 | appearance: none;
169 | background-color: #fff;
170 | background-image: url('data:image/svg+xml;charset=US-ASCII,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%22292.4%22%20height%3D%22292.4%22%3E%3Cpath%20fill%3D%22%23007CB2%22%20d%3D%22M287%2069.4a17.6%2017.6%200%200%200-13-5.4H18.4c-5%200-9.3%201.8-12.9%205.4A17.6%2017.6%200%200%200%200%2082.2c0%205%201.8%209.3%205.4%2012.9l128%20127.9c3.6%203.6%207.8%205.4%2012.8%205.4s9.2-1.8%2012.8-5.4L287%2095c3.5-3.5%205.4-7.8%205.4-12.8%200-5-1.9-9.2-5.5-12.8z%22%2F%3E%3C%2Fsvg%3E'),
171 | linear-gradient(to bottom, #ffffff 0%,#e5e5e5 100%);
172 | background-repeat: no-repeat, repeat;
173 | background-position: right .7em top 50%, 0 0;
174 | background-size: .65em auto, 100%;
175 | }
176 |
177 | .select::-ms-expand {
178 | display: none;
179 | }
180 |
181 | .select:hover {
182 | border-color: #888;
183 | }
184 |
185 | .select:focus {
186 | border-color: #aaa;
187 | box-shadow: 0 0 1px 3px rgba(59, 153, 252, .7);
188 | box-shadow: 0 0 0 3px -moz-mac-focusring;
189 | color: #222;
190 | outline: none;
191 | }
192 |
193 | .select option {
194 | font-weight:normal;
195 | }
196 |
--------------------------------------------------------------------------------
/Prescient/forms.py:
--------------------------------------------------------------------------------
1 | from flask_wtf import FlaskForm
2 | from wtforms import (StringField, SubmitField, PasswordField, BooleanField,
3 | TextAreaField, IntegerField, HiddenField, SelectField,
4 | DecimalField, DateTimeField)
5 | from wtforms import validators as v
6 | from Prescient.models import (User, Available_Securities, Watchlist_Group,
7 | default_date, WatchlistItems)
8 | from datetime import timedelta, date
9 | from flask_login import current_user
10 |
11 |
12 | class RegistrationForm(FlaskForm):
13 | username = StringField("Username", [v.Length(min=4, max=25)])
14 | password = PasswordField("New Password", [v.DataRequired(),
15 | v.Length(min=5),
16 | v.EqualTo("confirm", message="Passwords must match")])
17 | confirm = PasswordField("Confirm Password")
18 | submit = SubmitField("Register")
19 |
20 | def validate_username(self, username):
21 | user = User.query.filter_by(username=username.data).first()
22 | if user is not None:
23 | raise v.ValidationError('That username is already registered.')
24 |
25 |
26 | class LoginForm(FlaskForm):
27 | username = StringField("Username", validators=[v.DataRequired()])
28 | password = PasswordField("Password", validators=[v.DataRequired()])
29 | remember_me = BooleanField("Remember Me")
30 | submit = SubmitField("Sign In")
31 |
32 |
33 | class WatchlistItemsForm(FlaskForm):
34 | order_id = HiddenField("")
35 | watchlist = SelectField("Watchlist", validators=[v.InputRequired()])
36 | ticker = StringField("Ticker", validators=[v.Length(min=2, max=20),
37 | v.InputRequired()])
38 | quantity = IntegerField("Quantity", validators=[v.InputRequired(),
39 | v.NumberRange(min=-10000000, max=10000000)])
40 | price = DecimalField("Price", validators=[v.InputRequired(),
41 | v.NumberRange(min=0, max=100000)])
42 | trade_date = DateTimeField("Trade Date", default=default_date)
43 | sector = SelectField("Sector", validators=[v.InputRequired()])
44 | comments = TextAreaField("Comments", validators=[v.Optional(),
45 | v.Length(max=140)])
46 | submit = SubmitField("Add to Watchlist")
47 |
48 | def validate_ticker(self, ticker):
49 | ticker_check = Available_Securities.query.\
50 | filter_by(ticker=ticker.data).\
51 | first()
52 |
53 | if ticker_check is None:
54 | raise v.ValidationError(f'The ticker {ticker.data} is unavailable.')
55 |
56 | def validate_trade_date(self, trade_date):
57 | # Check if the trade exists.
58 | timestamp = WatchlistItems.query.\
59 | with_entities(WatchlistItems.created_timestamp).\
60 | filter_by(id=self.order_id.data).\
61 | first()
62 | if timestamp is None:
63 | return True
64 | trade_date = trade_date.data
65 | max_date = default_date()
66 |
67 | # Users can amend dates up to 100 days prior to the created_timestamp.
68 | lowest_date = timestamp[0] - timedelta(days=100)
69 |
70 | try:
71 | day_of_week = date.isoweekday(trade_date)
72 | except TypeError:
73 | raise v.ValidationError("Not a valid datetime value.")
74 |
75 | if trade_date > max_date:
76 | raise v.ValidationError("The trade and time cannot be a "
77 | "date in the future")
78 | elif trade_date < lowest_date:
79 | raise v.ValidationError("The trade and time must be within 100 "
80 | "days of the order creation date")
81 | elif day_of_week == 6 or day_of_week == 7:
82 | raise v.ValidationError("The trade date cannot fall on weekends.")
83 |
84 |
85 | class WatchlistGroupForm(FlaskForm):
86 | name = StringField("Watchlist Name", validators=[v.InputRequired(),
87 | v.Length(min=1, max=25)])
88 | submit = SubmitField("Create Watchlist")
89 |
90 | def validate_name(self, name):
91 | name = name.data
92 | user_id = current_user.id
93 | name_check = Watchlist_Group.query.\
94 | filter_by(name=name, user_id=user_id).\
95 | first()
96 |
97 | if name_check is not None:
98 | raise v.ValidationError("You can not create two watchlists "
99 | "with the same name!")
100 |
101 |
102 | class ChartForm(FlaskForm):
103 | ticker = SelectField("Ticker", validators=[v.InputRequired()])
104 | submit = SubmitField("Plot")
105 |
--------------------------------------------------------------------------------
/tests/test_extracts.py:
--------------------------------------------------------------------------------
1 | import os
2 | import unittest
3 | import sys
4 | from collections import namedtuple
5 | import pandas as pd
6 |
7 | topdir = os.path.join(os.path.dirname(__file__), "..")
8 | sys.path.append(topdir)
9 |
10 | from Prescient.database_tools.Extracts import (PositionSummary,
11 | PositionAccounting)
12 |
13 | """
14 | Units Tests
15 | position_1 - A single buy trade (long position).
16 | position_2 - 2 buy trades and 2 sell trades (long position to short position)
17 | position_3 - A sell trade and then a buy trade (short position)
18 | position_4 - 2 buy trades (long position)
19 | """
20 | Summary = namedtuple("Summary", ["ticker", "quantity", "price", "date"])
21 | position_1 = [('AMZN', 50, 1905.2, '2019-10-16')]
22 | position_2 = [('DIS', 20, 135.0, '2020-01-06'),
23 | ('DIS', 50, 140.0, '2020-01-15'),
24 | ('DIS', -30, 160.0, '2020-01-17'),
25 | ('DIS', -80, 142.0, '2020-01-21')]
26 | position_3 = [('KO', -85, 57.2, '2020-01-06'),
27 | ('KO', 53, 53.4, '2020-01-23')]
28 | position_4 = [('AAL', 10, 28.311, '2019-12-12'),
29 | ('AAL', 86, 29.88, '2020-02-06')]
30 |
31 |
32 | class PositionSummaryTests(unittest.TestCase):
33 |
34 | case_1 = [Summary(*trade) for trade in position_1]
35 | case_2 = [Summary(*trade) for trade in position_2]
36 | case_3 = [Summary(*trade) for trade in position_3]
37 | case_4 = [Summary(*trade) for trade in position_4]
38 |
39 | def test_open_lots(self):
40 | self.assertEqual(PositionSummary(self.case_1).total_open_lots(), 50)
41 | self.assertEqual(PositionSummary(self.case_2).total_open_lots(), -40)
42 | self.assertEqual(PositionSummary(self.case_3).total_open_lots(), -32)
43 | self.assertEqual(PositionSummary(self.case_4).total_open_lots(), 96)
44 |
45 | def test_average_cost(self):
46 | self.assertEqual(PositionSummary(self.case_1).avg_cost(), 1905.2)
47 | self.assertEqual(PositionSummary(self.case_2).avg_cost(), 142)
48 | self.assertEqual(PositionSummary(self.case_3).avg_cost(), 57.2)
49 | self.assertEqual(PositionSummary(self.case_4).avg_cost(), 29.7165625)
50 |
51 | def test_breakdown(self):
52 | result = [["2020-01-06", 20, 135],
53 | ["2020-01-15", 70, 138.5714],
54 | ["2020-01-17", 40, 140],
55 | ["2020-01-21", -40, 142]]
56 | self.assertEqual(PositionSummary(self.case_2).breakdown, result)
57 |
58 |
59 | class PositionAccountingTests(unittest.TestCase):
60 |
61 | case_2 = [Summary(*trade) for trade in position_2]
62 | maxDiff = None
63 |
64 | # Helper Method - creates Disney price history
65 | def price_table(self):
66 | dates = ["2020-01-06", "2020-01-07", "2020-01-08", "2020-01-09",
67 | "2020-01-10", "2020-01-13", "2020-01-14", "2020-01-15",
68 | "2020-01-16", "2020-01-17", "2020-01-20", "2020-01-21"]
69 | daily_prices = [145.65, 145.70, 145.40, 144.83,
70 | 144.62, 143.88, 145.20, 144.32,
71 | 145.12, 144.33, 143.56, 144.01]
72 | data = tuple(zip(dates, daily_prices))
73 | return data
74 |
75 | def test_position_performance(self):
76 | P = namedtuple("Pandas",
77 | ["date", "quantity", "avg_cost", "price", "pct_change"])
78 |
79 | perf = [["2020-01-06", 20.0, 135.0, 145.65, 7.889],
80 | ["2020-01-07", 20.0, 135.0, 145.70, 7.926],
81 | ["2020-01-08", 20.0, 135.0, 145.40, 7.704],
82 | ["2020-01-09", 20.0, 135.0, 144.83, 7.281],
83 | ["2020-01-10", 20.0, 135.0, 144.62, 7.126],
84 | ["2020-01-13", 20.0, 135.0, 143.88, 6.578],
85 | ["2020-01-14", 20.0, 135.0, 145.20, 7.556],
86 | ["2020-01-15", 70.0, 138.5714, 144.32, 4.148],
87 | ["2020-01-16", 70.0, 138.5714, 145.12, 4.726],
88 | ["2020-01-17", 40.0, 140.0, 144.33, 3.093],
89 | ["2020-01-20", 40.0, 140.0, 143.56, 2.543],
90 | ["2020-01-21", -40.0, 142.0, 144.01, -1.415]]
91 | data = [P(*day) for day in perf]
92 | prices = self.price_table()
93 | Performance = PositionAccounting(prices, self.case_2)
94 |
95 | self.assertEqual(Performance.performance_table(), data)
96 |
97 | def test_daily_valuation(self):
98 | mv = [["2020-01-06", 2913],
99 | ["2020-01-07", 2914],
100 | ["2020-01-08", 2908],
101 | ["2020-01-09", 2896.6],
102 | ["2020-01-10", 2892.4],
103 | ["2020-01-13", 2877.6],
104 | ["2020-01-14", 2904],
105 | ["2020-01-15", 10102.4],
106 | ["2020-01-16", 10158.4],
107 | ["2020-01-17", 5773.20],
108 | ["2020-01-20", 5742.4],
109 | ["2020-01-21", -5760.4]]
110 | mv = pd.DataFrame.from_records(mv, columns=["date", "market_val_DIS"])
111 | mv = mv.set_index("date")
112 |
113 | prices = self.price_table()
114 | Performance = PositionAccounting(prices, self.case_2)
115 | pd.testing.assert_frame_equal(Performance.daily_valuations(), mv)
116 |
117 |
118 | if __name__ == "__main__":
119 | unittest.main()
120 |
--------------------------------------------------------------------------------
/Prescient/views/charts.py:
--------------------------------------------------------------------------------
1 | from flask import (Blueprint, request,
2 | render_template,
3 | session)
4 | from flask_login import login_required, current_user
5 | from Prescient.database_tools.Extracts import PositionAccounting
6 | from Prescient.forms import ChartForm
7 | from Prescient.models import Watchlist_Group, WatchlistItems
8 | from sqlalchemy.sql import func
9 | import mysql.connector
10 |
11 | bp = Blueprint("charts", __name__)
12 |
13 |
14 | def get_group_id(watchlist, user_id):
15 | group_id = Watchlist_Group.query.\
16 | filter_by(name=watchlist, user_id=user_id).\
17 | first()
18 | if group_id is None:
19 | return None
20 | else:
21 | group_id = int(group_id.id)
22 | return group_id
23 |
24 |
25 | def get_group_names(user_id):
26 | names = Watchlist_Group.query.\
27 | filter_by(user_id=user_id).\
28 | all()
29 | if names is None:
30 | return []
31 | else:
32 | names_list = [i.name for i in names]
33 | return names_list
34 |
35 |
36 | def get_tickers(user_id, group_id):
37 | params = {"user_id": user_id, "group_id": group_id}
38 | tickers = WatchlistItems.query.\
39 | with_entities(WatchlistItems.ticker).\
40 | filter_by(**params).\
41 | order_by(WatchlistItems.ticker).\
42 | distinct(WatchlistItems.ticker).all()
43 |
44 | return [(item.ticker, item.ticker) for item in tickers]
45 |
46 |
47 | def get_market_prices(ticker):
48 | mydb = mysql.connector.connect(host="localhost",
49 | user="root",
50 | passwd="E6#hK-rA5!tn",
51 | database="prescientpricesdb")
52 | c = mydb.cursor()
53 | query = f"SELECT * FROM `{ticker}`"
54 | c.execute(query)
55 | prices = c.fetchall()
56 | c.close()
57 | mydb.close()
58 | return prices
59 |
60 |
61 | def get_trade_histroy(user_id, group_id, ticker):
62 | params = {"user_id": user_id, "group_id": group_id, "ticker": ticker}
63 | all_trades = WatchlistItems.query.\
64 | with_entities(WatchlistItems.ticker, WatchlistItems.quantity, WatchlistItems.price, func.date(WatchlistItems.trade_date).label("date")).\
65 | filter_by(**params).\
66 | order_by(WatchlistItems.trade_date).all()
67 | return all_trades
68 |
69 |
70 | def get_performance(user_id, group_id, ticker):
71 | prices = get_market_prices(ticker)
72 | trade_history = get_trade_histroy(user_id, group_id, ticker)
73 | Performance = PositionAccounting(prices, trade_history)
74 | performance_table = Performance.performance_table()
75 | return performance_table
76 |
77 |
78 | @bp.route("/performance_breakdown", methods=("GET", "POST"))
79 | @login_required
80 | def chart_breakdown():
81 | # A line chart with performance.
82 | user_id = current_user.id
83 |
84 | # Sets the first watchlist group as the selection to display
85 | user_watchlists = get_group_names(user_id)
86 | if len(user_watchlists) == 0:
87 | watchlist_id = 0
88 | first_watchlist_name = None
89 | session["ATEST"] = None
90 | else:
91 | first_watchlist_name = user_watchlists[0]
92 |
93 | if session["ATEST"] is None or session["ATEST"] == first_watchlist_name:
94 | session["ATEST"] = first_watchlist_name
95 | else:
96 | first_watchlist_name = session["ATEST"]
97 |
98 | watchlist_id = get_group_id(session.get('ATEST', None), user_id)
99 |
100 | user_tickers = get_tickers(user_id, watchlist_id)
101 |
102 | # Sets the first ticker as the selection to display
103 | if len(user_tickers) == 0:
104 | form = ChartForm()
105 | plot_data = []
106 | first_ticker = None
107 | else:
108 | first_ticker = user_tickers[0][0]
109 | form = ChartForm(ticker=first_ticker)
110 | plot_data = get_performance(user_id, watchlist_id, first_ticker)
111 | form.ticker.choices = user_tickers
112 |
113 | # POST REQUEST for ticker data
114 | if form.validate_on_submit():
115 | watchlist_name = session.get('ATEST', None)
116 | watchlist_id = get_group_id(watchlist_name, user_id)
117 |
118 | selection = form.ticker.data
119 | plot_data = get_performance(user_id, watchlist_id, selection)
120 | line_chart = plot_data
121 | breakdown = plot_data
122 | content = {"line_chart": line_chart, "breakdown": breakdown,
123 | "form": form,
124 | "user_watchlists": user_watchlists,
125 | "group_name": watchlist_name,
126 | "selected_ticker": selection}
127 | return render_template("charts/performance_breakdown.html", **content)
128 |
129 | # POST REQUEST for watchlist group
130 | if "btn_btn_default" in request.form:
131 | if request.method == 'POST':
132 | selection = request.form.get('watchlist_group_selection')
133 | selection_id = get_group_id(selection, user_id)
134 | user_tickers = get_tickers(user_id, selection_id)
135 | if len(user_tickers) == 0:
136 | form = ChartForm()
137 | plot_data = []
138 |
139 | else:
140 | first_ticker = user_tickers[0][0]
141 | form = ChartForm(ticker=first_ticker)
142 | plot_data = get_performance(user_id, selection_id, first_ticker)
143 | form.ticker.choices = user_tickers
144 | session["ATEST"] = selection
145 | line_chart = plot_data
146 | breakdown = plot_data
147 | content = {"line_chart": line_chart, "breakdown": breakdown,
148 | "form": form,
149 | "user_watchlists": user_watchlists,
150 | "group_name": selection,
151 | "selected_ticker": first_ticker}
152 | return render_template("charts/performance_breakdown.html", **content)
153 |
154 | line_chart = plot_data
155 | breakdown = plot_data
156 | content = {"line_chart": line_chart, "breakdown": breakdown,
157 | "form": form,
158 | "user_watchlists": user_watchlists,
159 | "group_name": first_watchlist_name,
160 | "selected_ticker": first_ticker}
161 | return render_template("charts/performance_breakdown.html", **content)
162 |
--------------------------------------------------------------------------------
/Prescient/templates/charts/performance_breakdown.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | {% extends 'base_layout.html' %}
4 |
5 | {% block header %}
6 | {% if group_name is defined and selected_ticker is not none %}
7 | {% block title %}{{group_name}} Performance Breakdown for {{selected_ticker}} {% endblock %}
8 |9 | {% elif group_name is not none and selected_ticker is none%} 10 |
11 | Add some securities here
13 |
14 | {% else %}
15 | {{group_name}} does not have any trade history
12 |
16 | Create a watchlist here
18 |
19 | {% endif %}
20 | {% endblock %}
21 |
22 | {% block content %}
23 | {% if group_name is defined and selected_ticker is not none %}
24 |
33 | You do not have any active watchlists.
17 |
34 |
159 | {% elif group_name is not none and selected_ticker is none%}
160 |
169 | {% else %}
170 | {% endif %}
171 | {% endblock %}
172 |
--------------------------------------------------------------------------------
/Prescient/views/dashboard.py:
--------------------------------------------------------------------------------
1 | from Prescient import db
2 | from flask import (Blueprint,
3 | render_template,
4 | request)
5 | from flask_login import login_required, current_user
6 | from werkzeug.exceptions import abort
7 | from sqlalchemy.sql import func
8 | from sqlalchemy.orm import aliased
9 | import plotly
10 | import plotly.graph_objects as go
11 | import json
12 | from Prescient.database_tools.Extracts import (Portfolio_Summary,
13 | PositionSummary,
14 | DashboardCharts)
15 | from Prescient.models import (Watchlist_Group, WatchlistItems,
16 | Available_Securities)
17 | import mysql.connector
18 |
19 | bp = Blueprint("dashboard", __name__)
20 |
21 |
22 | def get_worldmap(user_id, group_id):
23 | params = {"user_id": user_id, "group_id": group_id}
24 | w = aliased(WatchlistItems)
25 | s = aliased(Available_Securities)
26 | map_data = db.session.query(WatchlistItems, Available_Securities).\
27 | with_entities(func.count(w.ticker.distinct()).label("No. of Positions"), s.country.label("Country"), s.ISO_alpha3_codes.label("ISO Code")).\
28 | filter(s.ticker == w.ticker).\
29 | filter_by(**params).\
30 | group_by(s.ticker).\
31 | having(func.sum(w.quantity) != 0)
32 | map_dataframe = DashboardCharts.worldmap(map_data)
33 |
34 | fig = dict(data=[go.Choropleth(locations=map_dataframe["ISO Code"],
35 | z=map_dataframe["No. of Positions"],
36 | text=map_dataframe["Country"],
37 | colorscale="dense")],
38 | layout=dict(title="No. of Positions by Country",
39 | scene=dict(bgcolor='rgb(23,4,55)'),
40 | paper_bgcolor='rgba(0,0,0,0)',
41 | font=dict(size=20,
42 | color="#FFFFFF")))
43 |
44 | graphJSON = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
45 | return graphJSON
46 |
47 |
48 | def get_group_names(user_id):
49 | names = Watchlist_Group.query.filter_by(user_id=user_id).all()
50 | if names is None:
51 | return []
52 | else:
53 | names_list = [i.name for i in names]
54 | return names_list
55 |
56 |
57 | def get_tickers(user_id, group_id):
58 | params = {"user_id": user_id, "group_id": group_id}
59 | tickers = WatchlistItems.query.\
60 | with_entities(WatchlistItems.ticker).\
61 | filter_by(**params).\
62 | order_by(WatchlistItems.trade_date).\
63 | distinct(WatchlistItems.ticker).all()
64 |
65 | return [item.ticker for item in tickers]
66 |
67 |
68 | def get_trade_histroy(user_id, group_id, ticker):
69 | params = {"user_id": user_id, "group_id": group_id, "ticker": ticker}
70 | all_trades = WatchlistItems.query.\
71 | with_entities(WatchlistItems.ticker, WatchlistItems.quantity, WatchlistItems.price, func.date(WatchlistItems.trade_date).label("date")).\
72 | filter_by(**params).\
73 | order_by(WatchlistItems.trade_date).all()
74 | return all_trades
75 |
76 |
77 | def get_flows(user_id, group_id):
78 | params = {"user_id": user_id, "group_id": group_id}
79 | w = aliased(WatchlistItems)
80 | flows = WatchlistItems.query.\
81 | with_entities(func.date(w.trade_date).label("index"), func.sum(w.quantity*w.price*-1).label("flows")).\
82 | filter_by(**params).\
83 | group_by(func.date(w.trade_date)).\
84 | order_by(w.trade_date).all()
85 | return flows
86 |
87 |
88 | def get_market_prices(ticker):
89 | mydb = mysql.connector.connect(host="localhost",
90 | user="root",
91 | passwd="E6#hK-rA5!tn",
92 | database="prescientpricesdb")
93 | c = mydb.cursor()
94 | query = f"SELECT * FROM `{ticker}`"
95 | c.execute(query)
96 | prices = c.fetchall()
97 | c.close()
98 | mydb.close()
99 | return prices
100 |
101 |
102 | def get_position_summary(user_id, group_id):
103 | all_tickers = get_tickers(user_id, group_id)
104 | params = {"user_id": user_id, "group_id": group_id}
105 | all_trades = WatchlistItems.query.\
106 | with_entities(WatchlistItems.ticker, WatchlistItems.quantity, WatchlistItems.price, func.date(WatchlistItems.trade_date).label("date")).\
107 | filter_by(**params).\
108 | order_by(WatchlistItems.trade_date)
109 | summary_table = []
110 | for ticker in all_tickers:
111 | trade_history = [trade for trade in all_trades if trade.ticker == ticker]
112 | summary = PositionSummary(trade_history).get_summary()
113 | if summary.quantity != 0:
114 | summary_table.append(summary)
115 |
116 | if len(summary_table) > 7:
117 | summary_table = summary_table[0:7]
118 | return summary_table
119 |
120 |
121 | def get_portfolio_summary(user_id, group_id):
122 | Portfolio = Portfolio_Summary()
123 | tickers = get_tickers(user_id, group_id)
124 | for ticker in tickers:
125 | prices = get_market_prices(ticker)
126 | trades = get_trade_histroy(user_id, group_id, ticker)
127 | Portfolio.add_position(prices, trades)
128 | return Portfolio
129 |
130 |
131 | def get_group_id(watchlist, user_id):
132 | group_id = Watchlist_Group.query.filter_by(name=watchlist, user_id=user_id).first()
133 | if group_id is None:
134 | abort(404, f"the ID for {watchlist} doesn't exist.")
135 | else:
136 | group_id = int(group_id.id)
137 | return group_id
138 |
139 |
140 | @bp.route("/", methods=('GET', 'POST'))
141 | @login_required
142 | def index():
143 | user_id = current_user.id
144 |
145 | user_watchlists = get_group_names(user_id)
146 | if len(user_watchlists) == 0:
147 | watchlist_id = 0
148 | first_watchlist_name=None
149 | else:
150 | first_watchlist_name = user_watchlists[0]
151 | watchlist_id = get_group_id(first_watchlist_name, user_id)
152 | flows = get_flows(user_id, watchlist_id)
153 | if request.method == "POST":
154 | selection = request.form.get('watchlist_group_selection')
155 | selection_id = get_group_id(selection, user_id)
156 | flows = get_flows(user_id, selection_id)
157 | summary = get_position_summary(user_id, selection_id)
158 |
159 | Portfolio = get_portfolio_summary(user_id, selection_id)
160 | portfolio_breakdown = Portfolio.portfolio_breakdown
161 | portfolio_performance = Portfolio.generate_hpr(flows)
162 | Charts = DashboardCharts()
163 | pie_chart = Charts.get_pie_chart(portfolio_breakdown)
164 | bar_chart = Charts.get_bar_chart(portfolio_breakdown)
165 | map = get_worldmap(user_id, selection_id)
166 | line_chart = portfolio_performance
167 | content = {"summary": summary, "line_chart": line_chart,
168 | "pie_chart": pie_chart, "bar_chart": bar_chart,
169 | "user_watchlists": user_watchlists, "map": map,
170 | "group_name": selection}
171 |
172 | return render_template("securities/dashboard.html", **content)
173 |
174 | summary = get_position_summary(user_id, watchlist_id)
175 |
176 | Portfolio = get_portfolio_summary(user_id, watchlist_id)
177 | portfolio_breakdown = Portfolio.portfolio_breakdown
178 | Charts = DashboardCharts()
179 | pie_chart = Charts.get_pie_chart(portfolio_breakdown)
180 | bar_chart = Charts.get_bar_chart(portfolio_breakdown)
181 | portfolio_performance = Portfolio.generate_hpr(flows)
182 |
183 | line_chart = portfolio_performance
184 |
185 | map = get_worldmap(user_id, watchlist_id)
186 | content = {"summary": summary, "line_chart": line_chart,
187 | "pie_chart": pie_chart, "bar_chart": bar_chart,
188 | "user_watchlists": user_watchlists, "map": map,
189 | "group_name": first_watchlist_name}
190 | return render_template("securities/dashboard.html", **content)
191 |
--------------------------------------------------------------------------------
/Prescient/templates/securities/dashboard.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | {% extends 'base_layout.html' %}
4 | {% block header %}
5 | {% if line_chart and group_name %}
6 |
35 |
36 |
37 |
57 |
58 | | Date | 39 |Quantity | 40 |Average Cost | 41 |Price | 42 |Unrealised P&L | 43 |
|---|---|---|---|---|
| {{item.date}} | 49 |{{item.quantity}} | 50 |{{item.avg_cost}} | 51 |{{item.price}} | 52 |{{item.pct_change}}% | 53 |
59 |
60 |
61 |
148 |
149 | {% from "_formhelpers.html" import render_field %}
150 |
157 |
158 | {% block title %}{{current_user.username}}'s Portfolio Overview for {{group_name}}{% endblock %}
7 |8 | {% else %} 9 | {% endif %} 10 | {% endblock %} 11 | 12 | {% block content %} 13 | {% if line_chart and group_name is defined %} 14 | 23 | 24 |
25 |
302 | {% elif not line_chart and group_name is not none%}
303 |
26 |
27 |
28 |
46 |
47 | | Name | 30 |Quantity | 31 |Average Price | 32 |
|---|---|---|
| {{item.ticker}} | 39 |{{item.quantity}} | 40 |{{item.average_price}} | 41 | {% endif %} 42 |
48 |
49 |
50 |
115 |
118 |
202 |
203 |
204 |
205 |
206 |
210 |
211 |
212 |
213 |
214 |
301 |
304 | Why not add some securities?
307 |
308 | {%else%}
309 | Hi {{current_user.username}},
305 |Your watchlist '{{group_name}}' has no trade history!
306 |
310 | Get started! Create a watchlist here
313 |
314 | {% endif %}
315 | {% endblock %}
316 |
--------------------------------------------------------------------------------
/Prescient/views/watchlist.py:
--------------------------------------------------------------------------------
1 | from Prescient import db
2 | from flask import (Blueprint, flash, redirect,
3 | render_template, url_for, request)
4 | from werkzeug.exceptions import abort
5 | from flask_login import login_required, current_user
6 | from Prescient.forms import WatchlistItemsForm, WatchlistGroupForm
7 | from Prescient.models import (WatchlistItems, Sector_Definitions,
8 | Watchlist_Group, Available_Securities)
9 | from Prescient.database_tools.New_Prices import Price_Update
10 | from Prescient.database_tools.Extracts import PositionSummary
11 | from sqlalchemy.sql import func
12 | from sqlalchemy.orm import aliased
13 | import mysql.connector
14 |
15 | bp = Blueprint("watchlist", __name__)
16 |
17 |
18 | def update_db_prices(ticker):
19 | # check the tables. If the ticker doesnt exist get the price from AV and create a new table
20 | mydb = mysql.connector.connect(host="localhost",
21 | user="root",
22 | passwd="E6#hK-rA5!tn",
23 | database="prescientpricesdb")
24 | c = mydb.cursor()
25 | query = """SELECT table_name
26 | FROM information_schema.tables
27 | WHERE table_name=%s
28 | ORDER BY table_name"""
29 | param = (ticker,)
30 | print(query)
31 | c.execute(query, param)
32 | tables = c.fetchone()
33 | c.close()
34 | mydb.close()
35 |
36 | if tables is None:
37 | obj = Price_Update(ticker)
38 | obj.import_prices()
39 | else:
40 | print(f"{ticker} already exists")
41 |
42 |
43 | def get_sectors():
44 | sectors = Sector_Definitions.query.all()
45 | sectors_list = [(s.name, s.name) for s in sectors]
46 | return sectors_list
47 |
48 |
49 | def get_tradeable_tickers():
50 | # ticker, name, country, ISO code, benchmark
51 | tradeable_securities = Available_Securities.query.\
52 | order_by(Available_Securities.country, Available_Securities.name).\
53 | all()
54 | return tradeable_securities
55 |
56 |
57 | def get_group_names1(user_id):
58 | # returns list of items
59 | names = Watchlist_Group.query.\
60 | filter_by(user_id=user_id).\
61 | all()
62 | if names is None:
63 | return []
64 | else:
65 | names_list = [i.name for i in names]
66 | return names_list
67 |
68 |
69 | def get_watchlist_choices(user_id):
70 | # returns list of tuples
71 | names = Watchlist_Group.query.\
72 | filter_by(user_id=user_id).\
73 | all()
74 | if names is None:
75 | return []
76 | else:
77 | names_list = [(i.name, i.name) for i in names]
78 | return names_list
79 |
80 |
81 | def get_group_id(watchlist, user_id):
82 | group_id = Watchlist_Group.query.\
83 | filter_by(name=watchlist, user_id=user_id).\
84 | first()
85 | if group_id is None:
86 | abort(404, f"the ID for {watchlist} doesn't exist.")
87 | else:
88 | group_id = int(group_id.id)
89 | return group_id
90 |
91 |
92 | def get_tickers(user_id, group_id):
93 | params = {"user_id": user_id, "group_id": group_id}
94 | tickers = WatchlistItems.query.\
95 | with_entities(WatchlistItems.ticker).\
96 | filter_by(**params).\
97 | order_by(WatchlistItems.trade_date).\
98 | distinct(WatchlistItems.ticker).all()
99 |
100 | return [item.ticker for item in tickers]
101 |
102 |
103 | def get_position_summary(user_id, group_id):
104 | all_tickers = get_tickers(user_id, group_id)
105 | params = {"user_id": user_id, "group_id": group_id}
106 | w = aliased(WatchlistItems)
107 | all_trades = WatchlistItems.query.\
108 | with_entities(w.ticker, w.quantity, w.price, func.date(w.trade_date).label("date")).\
109 | filter_by(**params).\
110 | order_by(w.trade_date)
111 | summary_table = []
112 | for ticker in all_tickers:
113 | trade_history = [trade for trade in all_trades if trade.ticker == ticker]
114 | summary = PositionSummary(trade_history).get_summary()
115 | if summary.quantity != 0:
116 | summary_table.append(summary)
117 | return summary_table
118 |
119 |
120 | def check_watchlist_id(id, check_holder=True):
121 | info = WatchlistItems.query.filter_by(id=id).first()
122 | if info is None:
123 | abort(404, f"Order ID {id} doesn't exist.")
124 | if info.user_id != current_user.id:
125 | abort(403)
126 | return True
127 |
128 |
129 | @bp.route("/main", methods=('GET', 'POST'))
130 | @login_required
131 | def main():
132 | user_id = current_user.id
133 |
134 | user_watchlists = get_group_names1(user_id)
135 | if len(user_watchlists) == 0:
136 | watchlist_id = 0
137 | first_watchlist_name = None
138 | else:
139 | first_watchlist_name = user_watchlists[0]
140 | watchlist_id = get_group_id(first_watchlist_name, user_id)
141 | tradeable_securities = get_tradeable_tickers()
142 | form = WatchlistItemsForm()
143 | form.sector.choices = get_sectors()
144 | form.watchlist.choices = get_watchlist_choices(user_id)
145 | if request.method == "POST":
146 | selection = request.form.get('watchlist_group_selection')
147 | selection_id = get_group_id(selection, user_id)
148 | summary = get_position_summary(user_id, selection_id)
149 | watchlist = WatchlistItems.query.filter_by(user_id=user_id, group_id=selection_id)
150 | group_form = WatchlistGroupForm()
151 | content = {"watchlist": watchlist, "summary": summary, "form": form,
152 | "group_form": group_form, "group_name": selection,
153 | "user_watchlists": user_watchlists,
154 | "tradeable_securities": tradeable_securities}
155 | return render_template("watchlist/main.html", **content)
156 |
157 | watchlist = WatchlistItems.query.filter_by(user_id=user_id, group_id=watchlist_id)
158 | summary = get_position_summary(user_id, watchlist_id)
159 | group_form = WatchlistGroupForm()
160 | content = {"watchlist": watchlist, "summary": summary, "form": form,
161 | "group_form": group_form, "user_watchlists": user_watchlists,
162 | "group_name": first_watchlist_name,
163 | "tradeable_securities": tradeable_securities}
164 | return render_template("watchlist/main.html", **content)
165 |
166 |
167 | @bp.route('/create-group', methods=('GET', 'POST'))
168 | @login_required
169 | def create_group():
170 | group_form = WatchlistGroupForm()
171 | if group_form.validate_on_submit():
172 | name = group_form.name.data
173 | user_id = current_user.id
174 | new_group = Watchlist_Group(name=name, user_id=user_id)
175 | db.session.add(new_group)
176 | db.session.commit()
177 | flash(f"The Watchlist group '{name}' has been created!")
178 | return redirect(url_for("watchlist.main"))
179 | elif group_form.errors:
180 | for error_name, error_desc in group_form.errors.items():
181 | error_name = error_name.title()
182 | flash(f"{error_name}: {error_desc[0]}")
183 | return redirect(url_for("watchlist.main"))
184 |
185 |
186 | @bp.route('/create', methods=('GET', 'POST'))
187 | @login_required
188 | def create():
189 | form = WatchlistItemsForm()
190 | form.sector.choices = get_sectors()
191 | form.watchlist.choices = get_watchlist_choices(current_user.id)
192 |
193 | if form.validate_on_submit():
194 | watchlist = form.watchlist.data
195 | name = form.ticker.data
196 | quantity = form.quantity.data
197 | price = form.price.data
198 | sector = form.sector.data
199 | comments = form.comments.data
200 | user_id = current_user.id
201 | group_id = get_group_id(watchlist, user_id)
202 | new_item = WatchlistItems(watchlist=watchlist, ticker=name, quantity=quantity,
203 | price=price, sector=sector,
204 | comments=comments, user_id=user_id, group_id=group_id)
205 | db.session.add(new_item)
206 | db.session.commit()
207 | update_db_prices(name)
208 | flash(f"{name} has been added to your watchlist")
209 | return redirect(url_for("watchlist.main"))
210 | elif form.errors:
211 | for error_name, error_desc in form.errors.items():
212 | error_name = error_name.title()
213 | flash(f"{error_name}: {error_desc[0]}")
214 |
215 | return redirect(url_for("watchlist.main"))
216 |
217 |
218 | @bp.route('/Welcome to Prescient Finance
311 |Create portfolios and strategies your way!
312 |{% block title %}Entries for {{group_name}}{% endblock %}
11 | {% else %} 12 |
13 | Create a watchlist here
15 |
16 | {% endif %}
17 | {% endblock %}
18 |
19 | {% block content %}
20 | {% if group_name is not none %}
21 |
30 | You do not have any active watchlists.
14 |
31 |
32 |
33 |
51 |
52 | | Ticker | 35 |Quantity | 36 |Average Price | 37 |
|---|---|---|
| {{item.ticker}} | 44 |{{item.quantity}} | 45 |{{item.average_price}} | 46 | {% endif %} 47 |
53 | {% if current_user %} 54 | 56 |
57 |
81 |
83 |
58 |
79 |
80 |
84 |
102 |
104 |
85 |
100 |
101 |
105 |
125 |
127 |
106 |
123 |
124 |
128 |
164 | {% endif %}
165 |
166 |
129 |
162 |
163 | | Order ID | 170 |Ticker | 171 |Quantity | 172 |Price | 173 |Sector | 174 |Trade Date | 175 |comments | 176 |changes? | 177 |
|---|---|---|---|---|---|---|---|
| {{item.id}} | 183 |{{item.ticker}} | 184 |{{item.quantity}} | 185 |{{item.price}} | 186 |{{item.sector}} | 187 |{{item.trade_date.strftime('%d-%m-%Y')}} | 188 |{{item.comments}} | 189 |
190 | {% if current_user.id == item.user_id %}
191 |
193 |
194 |
218 |
221 | {% endif %}
222 |
195 |
216 |
217 | |
223 |
230 |
248 | {% endif %}
249 | {% endblock %}
250 |
--------------------------------------------------------------------------------
/Prescient/static/javascript/bootstrap/bootstrap.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * Generated using the Bootstrap Customizer (https://getbootstrap.com/docs/3.4/customize/)
3 | */
4 |
5 | /*!
6 | * Bootstrap v3.4.1 (https://getbootstrap.com/)
7 | * Copyright 2011-2020 Twitter, Inc.
8 | * Licensed under the MIT license
9 | */
10 |
11 | if (typeof jQuery === 'undefined') {
12 | throw new Error('Bootstrap\'s JavaScript requires jQuery')
13 | }
14 | +function ($) {
15 | 'use strict';
16 | var version = $.fn.jquery.split(' ')[0].split('.')
17 | if ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1) || (version[0] > 3)) {
18 | throw new Error('Bootstrap\'s JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4')
19 | }
20 | }(jQuery);
21 |
22 | /* ========================================================================
23 | * Bootstrap: modal.js v3.4.1
24 | * https://getbootstrap.com/docs/3.4/javascript/#modals
25 | * ========================================================================
26 | * Copyright 2011-2019 Twitter, Inc.
27 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
28 | * ======================================================================== */
29 |
30 |
31 | +function ($) {
32 | 'use strict';
33 |
34 | // MODAL CLASS DEFINITION
35 | // ======================
36 |
37 | var Modal = function (element, options) {
38 | this.options = options
39 | this.$body = $(document.body)
40 | this.$element = $(element)
41 | this.$dialog = this.$element.find('.modal-dialog')
42 | this.$backdrop = null
43 | this.isShown = null
44 | this.originalBodyPad = null
45 | this.scrollbarWidth = 0
46 | this.ignoreBackdropClick = false
47 | this.fixedContent = '.navbar-fixed-top, .navbar-fixed-bottom'
48 |
49 | if (this.options.remote) {
50 | this.$element
51 | .find('.modal-content')
52 | .load(this.options.remote, $.proxy(function () {
53 | this.$element.trigger('loaded.bs.modal')
54 | }, this))
55 | }
56 | }
57 |
58 | Modal.VERSION = '3.4.1'
59 |
60 | Modal.TRANSITION_DURATION = 300
61 | Modal.BACKDROP_TRANSITION_DURATION = 150
62 |
63 | Modal.DEFAULTS = {
64 | backdrop: true,
65 | keyboard: true,
66 | show: true
67 | }
68 |
69 | Modal.prototype.toggle = function (_relatedTarget) {
70 | return this.isShown ? this.hide() : this.show(_relatedTarget)
71 | }
72 |
73 | Modal.prototype.show = function (_relatedTarget) {
74 | var that = this
75 | var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
76 |
77 | this.$element.trigger(e)
78 |
79 | if (this.isShown || e.isDefaultPrevented()) return
80 |
81 | this.isShown = true
82 |
83 | this.checkScrollbar()
84 | this.setScrollbar()
85 | this.$body.addClass('modal-open')
86 |
87 | this.escape()
88 | this.resize()
89 |
90 | this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
91 |
92 | this.$dialog.on('mousedown.dismiss.bs.modal', function () {
93 | that.$element.one('mouseup.dismiss.bs.modal', function (e) {
94 | if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
95 | })
96 | })
97 |
98 | this.backdrop(function () {
99 | var transition = $.support.transition && that.$element.hasClass('fade')
100 |
101 | if (!that.$element.parent().length) {
102 | that.$element.appendTo(that.$body) // don't move modals dom position
103 | }
104 |
105 | that.$element
106 | .show()
107 | .scrollTop(0)
108 |
109 | that.adjustDialog()
110 |
111 | if (transition) {
112 | that.$element[0].offsetWidth // force reflow
113 | }
114 |
115 | that.$element.addClass('in')
116 |
117 | that.enforceFocus()
118 |
119 | var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
120 |
121 | transition ?
122 | that.$dialog // wait for modal to slide in
123 | .one('bsTransitionEnd', function () {
124 | that.$element.trigger('focus').trigger(e)
125 | })
126 | .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
127 | that.$element.trigger('focus').trigger(e)
128 | })
129 | }
130 |
131 | Modal.prototype.hide = function (e) {
132 | if (e) e.preventDefault()
133 |
134 | e = $.Event('hide.bs.modal')
135 |
136 | this.$element.trigger(e)
137 |
138 | if (!this.isShown || e.isDefaultPrevented()) return
139 |
140 | this.isShown = false
141 |
142 | this.escape()
143 | this.resize()
144 |
145 | $(document).off('focusin.bs.modal')
146 |
147 | this.$element
148 | .removeClass('in')
149 | .off('click.dismiss.bs.modal')
150 | .off('mouseup.dismiss.bs.modal')
151 |
152 | this.$dialog.off('mousedown.dismiss.bs.modal')
153 |
154 | $.support.transition && this.$element.hasClass('fade') ?
155 | this.$element
156 | .one('bsTransitionEnd', $.proxy(this.hideModal, this))
157 | .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
158 | this.hideModal()
159 | }
160 |
161 | Modal.prototype.enforceFocus = function () {
162 | $(document)
163 | .off('focusin.bs.modal') // guard against infinite focus loop
164 | .on('focusin.bs.modal', $.proxy(function (e) {
165 | if (document !== e.target &&
166 | this.$element[0] !== e.target &&
167 | !this.$element.has(e.target).length) {
168 | this.$element.trigger('focus')
169 | }
170 | }, this))
171 | }
172 |
173 | Modal.prototype.escape = function () {
174 | if (this.isShown && this.options.keyboard) {
175 | this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
176 | e.which == 27 && this.hide()
177 | }, this))
178 | } else if (!this.isShown) {
179 | this.$element.off('keydown.dismiss.bs.modal')
180 | }
181 | }
182 |
183 | Modal.prototype.resize = function () {
184 | if (this.isShown) {
185 | $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
186 | } else {
187 | $(window).off('resize.bs.modal')
188 | }
189 | }
190 |
191 | Modal.prototype.hideModal = function () {
192 | var that = this
193 | this.$element.hide()
194 | this.backdrop(function () {
195 | that.$body.removeClass('modal-open')
196 | that.resetAdjustments()
197 | that.resetScrollbar()
198 | that.$element.trigger('hidden.bs.modal')
199 | })
200 | }
201 |
202 | Modal.prototype.removeBackdrop = function () {
203 | this.$backdrop && this.$backdrop.remove()
204 | this.$backdrop = null
205 | }
206 |
207 | Modal.prototype.backdrop = function (callback) {
208 | var that = this
209 | var animate = this.$element.hasClass('fade') ? 'fade' : ''
210 |
211 | if (this.isShown && this.options.backdrop) {
212 | var doAnimate = $.support.transition && animate
213 |
214 | this.$backdrop = $(document.createElement('div'))
215 | .addClass('modal-backdrop ' + animate)
216 | .appendTo(this.$body)
217 |
218 | this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
219 | if (this.ignoreBackdropClick) {
220 | this.ignoreBackdropClick = false
221 | return
222 | }
223 | if (e.target !== e.currentTarget) return
224 | this.options.backdrop == 'static'
225 | ? this.$element[0].focus()
226 | : this.hide()
227 | }, this))
228 |
229 | if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
230 |
231 | this.$backdrop.addClass('in')
232 |
233 | if (!callback) return
234 |
235 | doAnimate ?
236 | this.$backdrop
237 | .one('bsTransitionEnd', callback)
238 | .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
239 | callback()
240 |
241 | } else if (!this.isShown && this.$backdrop) {
242 | this.$backdrop.removeClass('in')
243 |
244 | var callbackRemove = function () {
245 | that.removeBackdrop()
246 | callback && callback()
247 | }
248 | $.support.transition && this.$element.hasClass('fade') ?
249 | this.$backdrop
250 | .one('bsTransitionEnd', callbackRemove)
251 | .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
252 | callbackRemove()
253 |
254 | } else if (callback) {
255 | callback()
256 | }
257 | }
258 |
259 | // these following methods are used to handle overflowing modals
260 |
261 | Modal.prototype.handleUpdate = function () {
262 | this.adjustDialog()
263 | }
264 |
265 | Modal.prototype.adjustDialog = function () {
266 | var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight
267 |
268 | this.$element.css({
269 | paddingLeft: !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
270 | paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
271 | })
272 | }
273 |
274 | Modal.prototype.resetAdjustments = function () {
275 | this.$element.css({
276 | paddingLeft: '',
277 | paddingRight: ''
278 | })
279 | }
280 |
281 | Modal.prototype.checkScrollbar = function () {
282 | var fullWindowWidth = window.innerWidth
283 | if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
284 | var documentElementRect = document.documentElement.getBoundingClientRect()
285 | fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
286 | }
287 | this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
288 | this.scrollbarWidth = this.measureScrollbar()
289 | }
290 |
291 | Modal.prototype.setScrollbar = function () {
292 | var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
293 | this.originalBodyPad = document.body.style.paddingRight || ''
294 | var scrollbarWidth = this.scrollbarWidth
295 | if (this.bodyIsOverflowing) {
296 | this.$body.css('padding-right', bodyPad + scrollbarWidth)
297 | $(this.fixedContent).each(function (index, element) {
298 | var actualPadding = element.style.paddingRight
299 | var calculatedPadding = $(element).css('padding-right')
300 | $(element)
301 | .data('padding-right', actualPadding)
302 | .css('padding-right', parseFloat(calculatedPadding) + scrollbarWidth + 'px')
303 | })
304 | }
305 | }
306 |
307 | Modal.prototype.resetScrollbar = function () {
308 | this.$body.css('padding-right', this.originalBodyPad)
309 | $(this.fixedContent).each(function (index, element) {
310 | var padding = $(element).data('padding-right')
311 | $(element).removeData('padding-right')
312 | element.style.paddingRight = padding ? padding : ''
313 | })
314 | }
315 |
316 | Modal.prototype.measureScrollbar = function () { // thx walsh
317 | var scrollDiv = document.createElement('div')
318 | scrollDiv.className = 'modal-scrollbar-measure'
319 | this.$body.append(scrollDiv)
320 | var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
321 | this.$body[0].removeChild(scrollDiv)
322 | return scrollbarWidth
323 | }
324 |
325 |
326 | // MODAL PLUGIN DEFINITION
327 | // =======================
328 |
329 | function Plugin(option, _relatedTarget) {
330 | return this.each(function () {
331 | var $this = $(this)
332 | var data = $this.data('bs.modal')
333 | var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
334 |
335 | if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
336 | if (typeof option == 'string') data[option](_relatedTarget)
337 | else if (options.show) data.show(_relatedTarget)
338 | })
339 | }
340 |
341 | var old = $.fn.modal
342 |
343 | $.fn.modal = Plugin
344 | $.fn.modal.Constructor = Modal
345 |
346 |
347 | // MODAL NO CONFLICT
348 | // =================
349 |
350 | $.fn.modal.noConflict = function () {
351 | $.fn.modal = old
352 | return this
353 | }
354 |
355 |
356 | // MODAL DATA-API
357 | // ==============
358 |
359 | $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
360 | var $this = $(this)
361 | var href = $this.attr('href')
362 | var target = $this.attr('data-target') ||
363 | (href && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
364 |
365 | var $target = $(document).find(target)
366 | var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
367 |
368 | if ($this.is('a')) e.preventDefault()
369 |
370 | $target.one('show.bs.modal', function (showEvent) {
371 | if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
372 | $target.one('hidden.bs.modal', function () {
373 | $this.is(':visible') && $this.trigger('focus')
374 | })
375 | })
376 | Plugin.call($target, option, this)
377 | })
378 |
379 | }(jQuery);
380 |
381 | /* ========================================================================
382 | * Bootstrap: transition.js v3.4.1
383 | * https://getbootstrap.com/docs/3.4/javascript/#transitions
384 | * ========================================================================
385 | * Copyright 2011-2019 Twitter, Inc.
386 | * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
387 | * ======================================================================== */
388 |
389 |
390 | +function ($) {
391 | 'use strict';
392 |
393 | // CSS TRANSITION SUPPORT (Shoutout: https://modernizr.com/)
394 | // ============================================================
395 |
396 | function transitionEnd() {
397 | var el = document.createElement('bootstrap')
398 |
399 | var transEndEventNames = {
400 | WebkitTransition : 'webkitTransitionEnd',
401 | MozTransition : 'transitionend',
402 | OTransition : 'oTransitionEnd otransitionend',
403 | transition : 'transitionend'
404 | }
405 |
406 | for (var name in transEndEventNames) {
407 | if (el.style[name] !== undefined) {
408 | return { end: transEndEventNames[name] }
409 | }
410 | }
411 |
412 | return false // explicit for ie8 ( ._.)
413 | }
414 |
415 | // https://blog.alexmaccaw.com/css-transitions
416 | $.fn.emulateTransitionEnd = function (duration) {
417 | var called = false
418 | var $el = this
419 | $(this).one('bsTransitionEnd', function () { called = true })
420 | var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
421 | setTimeout(callback, duration)
422 | return this
423 | }
424 |
425 | $(function () {
426 | $.support.transition = transitionEnd()
427 |
428 | if (!$.support.transition) return
429 |
430 | $.event.special.bsTransitionEnd = {
431 | bindType: $.support.transition.end,
432 | delegateType: $.support.transition.end,
433 | handle: function (e) {
434 | if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
435 | }
436 | }
437 | })
438 |
439 | }(jQuery);
440 |
--------------------------------------------------------------------------------
/Prescient/database_tools/Extracts.py:
--------------------------------------------------------------------------------
1 | import pandas as pd
2 | from collections import deque, namedtuple
3 |
4 |
5 | class PositionSummary(object):
6 | """
7 | Takes the trade history for a user's watchlist from the database and it's
8 | ticker. Then applies the FIFO accounting methodology to calculate the
9 | overall positions status i.e. final open lots, average cost and a breakdown
10 | of the open lots.
11 |
12 | This is a queue data structure.
13 | """
14 |
15 | def __init__(self, trade_history):
16 |
17 | self.trade_history = trade_history
18 | self.average_cost = None
19 | self.open_lots = None
20 | self.ticker = self.set_ticker()
21 |
22 | self.buy_quantities = deque([])
23 | self.buy_prices = deque([])
24 | self.buy_dates = deque([])
25 | self.sell_quantities = deque([])
26 | self.sell_prices = deque([])
27 | self.sell_dates = deque([])
28 | self.open_direction = None
29 |
30 | self.breakdown = []
31 | self.net_position = 0
32 |
33 | self._apply_fifo()
34 |
35 | def __repr__(self):
36 | return (f"
231 |
246 |
247 |