├── .gitignore
├── LICENSE
├── Prescient
    ├── MainDB.db
    ├── Security_PricesDB.db
    ├── __init__.py
    ├── config.py
    ├── database_tools
    │   ├── Extracts.py
    │   ├── New_Prices.py
    │   ├── __init__.py
    │   ├── csv_files
    │   │   ├── FTSE_Sectors.csv
    │   │   └── stock_tickers_av.csv
    │   ├── load_csv_files_manual.py
    │   ├── load_prices_manual.py
    │   └── update_existing_prices.py
    ├── forms.py
    ├── models
    │   ├── __init__.py
    │   ├── db_securities.py
    │   ├── user.py
    │   └── watchlist.py
    ├── static
    │   ├── assets
    │   │   ├── finance-prescient2.png
    │   │   └── finance-prescient2backup.png
    │   ├── base_style.css
    │   ├── javascript
    │   │   ├── bootstrap
    │   │   │   ├── bootstrap.js
    │   │   │   └── jquery-3.4.1.js
    │   │   ├── navbarscript.js
    │   │   ├── watchlist-all-security-filter.js
    │   │   └── watchlist-filter.js
    │   └── styles
    │   │   ├── auth-styles.css
    │   │   ├── bootstrap
    │   │       └── bootstrap.css
    │   │   ├── dashboard-styles.css
    │   │   ├── performance-styles.css
    │   │   └── watchlist-styles.css
    ├── templates
    │   ├── _formhelpers.html
    │   ├── auth
    │   │   ├── login.html
    │   │   └── register.html
    │   ├── base_layout.html
    │   ├── charts
    │   │   └── performance_breakdown.html
    │   ├── securities
    │   │   └── dashboard.html
    │   ├── test.html
    │   └── watchlist
    │   │   └── main.html
    ├── test.db
    └── views
    │   ├── __init__.py
    │   ├── auth.py
    │   ├── charts.py
    │   ├── dashboard.py
    │   └── watchlist.py
├── README.md
├── migrations
    ├── README
    ├── __pycache__
    │   └── env.cpython-37.pyc
    ├── alembic.ini
    ├── env.py
    ├── script.py.mako
    └── versions
    │   ├── __pycache__
    │       └── ac98739c7dd8_.cpython-37.pyc
    │   └── ac98739c7dd8_.py
├── requirements.txt
├── screenshots
    ├── Dashboard.PNG
    ├── performance-charts.PNG
    └── watchlist.PNG
├── tests
    ├── test_auth.py
    ├── test_extracts.py
    └── test_watchlists.py
└── wsgi.py


/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/
2 | .idea
3 | .db
4 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Ramon Williams
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Prescient/MainDB.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/MainDB.db


--------------------------------------------------------------------------------
/Prescient/Security_PricesDB.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/Security_PricesDB.db


--------------------------------------------------------------------------------
/Prescient/__init__.py:
--------------------------------------------------------------------------------
 1 | from flask import Flask, session
 2 | from .config import Config
 3 | from datetime import timedelta
 4 | 
 5 | from flask_sqlalchemy import SQLAlchemy
 6 | from flask_migrate import Migrate
 7 | from flask_login import LoginManager
 8 | 
 9 | app = Flask(__name__)
10 | app.config.from_object(Config)
11 | db = SQLAlchemy(app)
12 | migrate = Migrate(app, db)
13 | 
14 | login = LoginManager(app)
15 | login.login_view = "auth.login"
16 | login.refresh_view = "auth.login"
17 | login.needs_refresh_message = (u"Your Session timedout, please re-login")
18 | login.needs_refresh_message_category = "info"
19 | 
20 | from . import views
21 | from . import models
22 | 
23 | app.register_blueprint(views.auth.bp)
24 | app.register_blueprint(views.dashboard.bp)
25 | app.add_url_rule("/", endpoint="dashboard")
26 | app.register_blueprint(views.watchlist.bp)
27 | app.register_blueprint(views.charts.bp)
28 | 
29 | # before a request is made check if the session should be timedout
30 | @app.before_request
31 | def before_request():
32 |     session.permanent = True
33 |     app.permanent_session_lifetime = timedelta(minutes=10)
34 | 


--------------------------------------------------------------------------------
/Prescient/config.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | basedir = os.path.abspath(os.path.dirname(__file__))
 4 | 
 5 | 
 6 | class Config(object):
 7 |     """docstring for Config."""
 8 |     # General Configurations
 9 |     SECRET_KEY = os.environ.get("SECRET_KEY") or "dev"
10 | 
11 |     # Database Configurations
12 |     SQLALCHEMY_DATABASE_URI = "mysql://root:E6#hK-rA5!tn@localhost/prescientmaindb"
13 |     SQLALCHEMY_BINDS = {"Security_PricesDB": ("mysql://root:E6#hK-rA5!tn@localhost/prescientpricesdb")}
14 |     SQLALCHEMY_TRACK_MODIFICATIONS = False
15 | 


--------------------------------------------------------------------------------
/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"<Ticker: {self.ticker}, Quantity: {self.net_position}>")
 37 | 
 38 |     def set_ticker(self):
 39 |         tickers = set([i[0] for i in self.trade_history])
 40 |         if len(tickers) == 1:
 41 |             return self.trade_history[0][0]
 42 |         else:
 43 |             raise ValueError("The Trade History for this security contains multiple tickers")
 44 | 
 45 |     def total_open_lots(self):
 46 |         """ returns the sum of the positions open lots"""
 47 |         if self.open_direction == "long":
 48 |             return sum(self.buy_quantities)
 49 |         elif self.open_direction == "short":
 50 |             return sum(self.sell_quantities)
 51 |         else:
 52 |             return None
 53 | 
 54 |     def total_market_value(self):
 55 |         """Returns the position's market value"""
 56 |         total = None
 57 |         if self.buy_quantities and self.open_direction == "long":
 58 |             zipped = zip(self.buy_quantities, self.buy_prices)
 59 |             total = (quantity*price for quantity, price in zipped)
 60 | 
 61 |         elif self.sell_quantities and self.open_direction == "short":
 62 |             zipped = zip(self.sell_quantities, self.sell_prices)
 63 |             total = (quantity*price for quantity, price in zipped)
 64 | 
 65 |         return sum(total) if total is not None else None
 66 | 
 67 |     def get_average_cost(self):
 68 |         """Returns the weighted average cost of the positions open lots."""
 69 |         open_lots = self.total_open_lots()
 70 |         if open_lots == 0 or not open_lots:
 71 |             return 0
 72 | 
 73 |         return abs(self.total_market_value()/self.total_open_lots())
 74 | 
 75 |     def remove_trade(self, direction):
 76 |         if direction == "buy":
 77 |             popped_quantity = self.buy_quantities.popleft()
 78 |             self.buy_prices.popleft()
 79 |             self.buy_dates.popleft()
 80 |         elif direction == "sell":
 81 |             popped_quantity = self.sell_quantities.popleft()
 82 |             self.sell_prices.popleft()
 83 |             self.sell_dates.popleft()
 84 |         else:
 85 |             raise NameError("why did this happen")
 86 |         return popped_quantity
 87 | 
 88 |     def _collapse_trade(self):
 89 |         if self.sell_quantities:
 90 |             if self.sell_quantities[0] >= 0:
 91 |                 self.remove_trade("sell")
 92 | 
 93 |         if self.buy_quantities:
 94 |             if self.buy_quantities[0] <= 0:
 95 |                 self.remove_trade("buy")
 96 | 
 97 |     def get_summary(self):
 98 |         """
 99 |         Returns a named tuple of the ticker, net position and the average
100 |         price of the opens lots
101 |         """
102 |         Summary = namedtuple("Summary",
103 |                              ["ticker", "quantity", "average_price"])
104 |         ticker = self.ticker
105 |         quantity = self.net_position
106 |         average_price = round(self.average_cost, 4)
107 |         return Summary(ticker, quantity, average_price)
108 | 
109 |     def add(self, side, units, price, date):
110 |         if side == "buy":
111 |             self.buy_quantities.append(units)
112 |             self.buy_prices.append(price)
113 |             self.buy_dates.append(date)
114 |         elif side == "sell":
115 |             self.sell_quantities.append(units)
116 |             self.sell_prices.append(price)
117 |             self.sell_dates.append(date)
118 | 
119 |     def _set_direction(self):
120 |         """
121 |         Checks if there has been a reversal in the users overall
122 |         trade direction and sets that direction accordingly.
123 |         """
124 |         if self.open_direction == "short" and self.net_position > 0:
125 |             self.open_direction = "long"
126 |         elif self.open_direction == "long" and self.net_position < 0:
127 |             self.open_direction = "short"
128 | 
129 |     def set_initial_trade(self):
130 | 
131 |         units = self.trade_history[0].quantity
132 |         price = self.trade_history[0].price
133 |         date = self.trade_history[0].date
134 |         if units >= 0:
135 |             self.open_direction = "long"
136 |             self.add("buy", units, price, date)
137 | 
138 |         else:
139 |             self.open_direction = "short"
140 |             self.add("sell", units, price, date)
141 |         self.average_cost = self.get_average_cost()
142 |         self.net_position = self.total_open_lots()
143 |         self.breakdown.append([date, self.net_position, self.average_cost])
144 | 
145 |     def _apply_fifo(self):
146 |         """
147 |         This algorithm iterate over the trade history. It sets the
148 |         initial trade direction to get the initial open lots and then increases
149 |         or closes lots based on each trade.
150 | 
151 |         In the event that a position was initally long then becomes short or
152 |         vice versa the open lots will be increased or closed accordingly.
153 |         """
154 |         if self.trade_history:
155 |             self.set_initial_trade()
156 |         else:
157 |             return []
158 | 
159 |         trades = len(self.trade_history)
160 |         c1 = 1  # counter
161 | 
162 |         while c1 < trades:
163 |             units = self.trade_history[c1].quantity
164 |             price = self.trade_history[c1].price
165 |             date = self.trade_history[c1].date
166 | 
167 |             if units*self.net_position > 0:  # if true both trades have the same sign
168 |                 if self.open_direction == "long":
169 |                     self.add("buy", units, price, date)
170 |                 else:
171 |                     self.add("sell", units, price, date)
172 |             elif units*self.net_position == 0:  # position is flat
173 |                 if units >= 0:
174 |                     self.open_direction = "long"
175 |                     self.add("buy", units, price, date)
176 | 
177 |                 else:
178 |                     self.open_direction = "short"
179 |                     self.add("sell", units, price, date)
180 | 
181 |             else:  # both trades are in different directions
182 |                 if self.open_direction == "long":
183 |                     self.add("sell", units, price, date)
184 |                     # while the lots are not empty
185 |                     while self.sell_quantities and self.buy_quantities:
186 | 
187 |                         if abs(self.sell_quantities[0]) >= self.buy_quantities[0]:
188 |                             self.sell_quantities[0] += self.buy_quantities[0]
189 |                             self.remove_trade("buy")
190 | 
191 |                         else:
192 |                             temp = self.remove_trade("sell")
193 |                             self.buy_quantities[0] += temp
194 |                     self.net_position += units  # subtract units from net position
195 | 
196 |                 else:  # self.open_direction == "short"
197 |                     self.add("buy", units, price, date)
198 |                     while self.sell_quantities and self.buy_quantities:
199 |                         if self.buy_quantities[0] >= abs(self.sell_quantities[0]):
200 |                             self.buy_quantities[0] += self.sell_quantities[0]
201 |                             self.remove_trade("sell")
202 |                         else:
203 |                             temp = self.remove_trade("buy")
204 |                             self.sell_quantities[0] += temp
205 |                     self.net_position += units
206 | 
207 |             self._collapse_trade()
208 |             self._set_direction()
209 |             self.average_cost = round(self.get_average_cost(), 4)
210 |             self.net_position = self.total_open_lots()
211 |             self.breakdown.append([date, self.net_position, self.average_cost])
212 |             c1 += 1
213 | 
214 | 
215 | class PositionAccounting(PositionSummary):
216 |     """
217 |     Inherits from the Position Summary and applies accounting methods
218 |     to a Position
219 |     """
220 | 
221 |     def __init__(self, close_prices, trade_history):
222 |         super().__init__(trade_history)
223 |         self.close_prices = close_prices  # Daily market prices
224 | 
225 |     def performance_table(self):
226 |         """
227 |         Combines the position breakdown with the daily prices to calculate
228 |         daily unrealised P&L. The Daily unrealised P&L is the difference
229 |         between the postion's weighted average cost and the market
230 |         price.
231 |         """
232 |         df = pd.DataFrame(self.close_prices, columns=["date", "price"])
233 |         df = df.set_index("date")
234 |         df["quantity"] = float("nan")
235 |         df["avg_cost"] = float("nan")
236 |         start_date = str(self.breakdown[0][0])
237 |         df2 = df.loc[start_date:]
238 |         df2 = df2.copy()  # copied to prevent chained assignment
239 |         for row in self.breakdown:
240 |             df2.at[str(row[0]), "quantity"] = row[1]
241 |             df2.at[str(row[0]), "avg_cost"] = row[2]
242 |         df2["quantity"] = df2["quantity"].fillna(method="ffill")
243 |         df2["price"] = df2["price"].fillna(method="ffill")
244 |         df2["avg_cost"] = df2["avg_cost"].fillna(method="ffill")
245 |         df2["price"] = pd.to_numeric(df2["price"])
246 |         df2.loc[df2['quantity'] <= 0, 'Long/Short'] = -1
247 |         df2.loc[df2['quantity'] > 0, 'Long/Short'] = 1
248 | 
249 |         df2["pct_change"] = (((df2["price"] - df2["avg_cost"])/df2["avg_cost"])*df2["Long/Short"])*100
250 |         df2["pct_change"] = round(df2["pct_change"], 3)
251 |         df2 = df2.reset_index()
252 |         df2 = df2[["date", "quantity", "avg_cost", "price", "pct_change"]]
253 |         df2 = list(df2.itertuples(index=False))
254 |         return df2
255 | 
256 |     def daily_valuations(self):
257 |         """
258 |         Combines the position breakdown with the daily prices to calculate
259 |         daily market value. The Daily market value is the positions quantity
260 |         multiplied by the market price.
261 |         """
262 |         df = pd.DataFrame(self.close_prices, columns=["date", "price"])
263 |         df = df.set_index("date")
264 |         df["quantity"] = float("nan")
265 |         df["market_val"] = float("nan")
266 |         # the prices starting from the first date the security was held
267 |         start_date = str(self.breakdown[0][0])
268 | 
269 |         df2 = df.loc[start_date:]
270 |         df2 = df2.copy()  # copied to prevent chained assignment
271 |         # update the quantity at each date
272 |         for row in self.breakdown:
273 |             df2.at[str(row[0]), "quantity"] = row[1]
274 |         df2["price"] = df2["price"].fillna(method="ffill")
275 |         df2["quantity"] = df2["quantity"].fillna(method="ffill")
276 | 
277 |         df2["price"] = pd.to_numeric(df2["price"])
278 |         df2["market_val"] = round((df2["price"] * df2["quantity"]), 3)
279 | 
280 |         df2 = df2[["market_val"]]
281 |         new_name = f"market_val_{self.ticker}"
282 |         new_header = {"market_val": new_name}
283 |         df2 = df2.rename(columns=new_header)
284 |         return df2
285 | 
286 | 
287 | class Portfolio_Summary(object):
288 |     """
289 |     This is a collection of the Positions for the user accounts, priced as of
290 |     the latest market prices
291 |     """
292 |     def __init__(self):
293 |         self.portfolio_breakdown = pd.DataFrame()
294 | 
295 |     def add_position(self, close_prices, trade_history):
296 |         """
297 |         Adds each positions daily market value to the portfolio breakdown.
298 |         """
299 |         Position = PositionAccounting(close_prices, trade_history)
300 |         Position_valuation = Position.daily_valuations()
301 |         if self.portfolio_breakdown.empty:
302 |             self.portfolio_breakdown = Position_valuation
303 | 
304 |         else:
305 |             self.portfolio_breakdown = self.portfolio_breakdown.join(Position_valuation)
306 |         self.portfolio_breakdown = self.portfolio_breakdown.fillna(method="ffill")
307 | 
308 |     def net_valuations(self):
309 |         """
310 |         returns the portfolios daily market value
311 |         """
312 |         valuation = self.portfolio_breakdown.copy()
313 |         valuation["portfolio_val"] = valuation.sum(axis=1)
314 |         valuation = valuation[["portfolio_val"]]
315 |         return valuation
316 | 
317 |     def convert_flows(self, flows):
318 |         """
319 |         Using the Holding Period Return (HPR) methodology. Purchases of
320 |         securities are accounted as fund inflows and the sale of securities are
321 |         accounted as increases in cash.
322 | 
323 |         By creating the cumulative sum of these values we can maintain an
324 |         accurate calculation of the HPR which can be distorted as purchases and
325 |         sells are added to the trades.
326 |         """
327 |         df_flows = pd.DataFrame(flows, columns=["date", "flows"])
328 |         df_flows["cash"] = float("nan")
329 |         df_flows["inflows"] = float("nan")
330 |         df_flows["date"] = df_flows["date"].astype(str)
331 |         df_flows["cash"] = df_flows.loc[df_flows['flows'] > 0, "flows"]
332 |         df_flows["inflows"] = df_flows.loc[df_flows['flows'] <= 0, "flows"]
333 |         df_flows["cash"] = df_flows["cash"].cumsum()
334 |         df_flows["inflows"] = df_flows["inflows"].abs()
335 |         df_flows = df_flows.set_index("date")  # need to sum groupby date
336 |         df_flows = df_flows.groupby([df_flows.index]).sum()
337 |         df_flows = df_flows.drop(columns=['flows'])
338 |         df_flows = df_flows.replace({'cash': 0, 'inflows': 0}, float("nan"))
339 |         return df_flows
340 | 
341 |     def generate_hpr(self, flows):
342 |         """
343 |         Where PortVal = Portfolio Value. The Formula for the Daily
344 |         Holding Period Return (HPR) is calculated as follows:
345 |         (Ending PortVal) / (Previous PortVal After Cash Flow) – 1.
346 | 
347 |         1. Add the cash from the sale of securities to the portfolio value.
348 |         2. shift the total portfolio value column to allow us to easily
349 |            caclulate the Percentage change before and after each cash flow.
350 |         Returns a named tuple of daily HPR % changes.
351 |         """
352 |         df_flows = self.convert_flows(flows)
353 |         valuation = self.net_valuations()
354 |         valuation = valuation.join(df_flows)
355 |         valuation["cash"] = valuation["cash"].fillna(method="ffill")
356 |         valuation = valuation.fillna(value=0)
357 |         valuation["total_portfolio_val"] = valuation["portfolio_val"] + valuation["cash"]
358 |         valuation["portfolio_val"] = valuation["total_portfolio_val"].shift(1)
359 |         valuation["pct_change"] = ((valuation["total_portfolio_val"])/(valuation["portfolio_val"]+valuation["inflows"])-1)*100
360 |         valuation["pct_change"] = round(valuation["pct_change"], 3)
361 |         valuation = valuation.reset_index()
362 |         valuation = list(valuation.itertuples(index=False))
363 |         return valuation
364 | 
365 | 
366 | class DashboardCharts(object):
367 |     """
368 |     Various methods that take portfolio data from the database and cleans the
369 |     data so that it can be plotted into graphs on the front end
370 |     """
371 | 
372 |     def worldmap(map_data):
373 |         """
374 |         Groups the users positions by the country and ISO Count
375 |         the aggregagte function used here is COUNT
376 |         """
377 |         df = pd.DataFrame(map_data)
378 |         if not df.empty:
379 |             df = df.groupby(["Country", "ISO Code"]).count().reset_index()
380 |             return df
381 |         else:
382 |             return pd.DataFrame(columns=["No. of Positions",
383 |                                          "Country",
384 |                                          "ISO Code"])
385 | 
386 |     def get_pie_chart(self, portfolio_valuation):
387 |         """
388 |         Returns a named tuple of the largest positions by absolute exposure
389 |         in descending order. For the portfolios that contain more than 6
390 |         positions the next n positons are aggregated to and classified
391 |         'as other'
392 |         """
393 |         df = portfolio_valuation.tail(1)
394 |         df = df.T.reset_index()  # transpose table to make the tickers the rows
395 |         if df.empty:
396 |             return df
397 | 
398 |         new_headers = {df.columns[0]: "ticker", df.columns[1]: "Market_val"}
399 |         df = df.rename(columns=new_headers)
400 |         df["Market_val"] = abs(df["Market_val"])
401 |         total_portfolio_val = sum(df["Market_val"])
402 | 
403 |         df["ticker"] = df["ticker"].replace("market_val_", "", regex=True)
404 |         df["market_val_perc"] = round(df["Market_val"]/total_portfolio_val, 2)
405 |         df = df[df["Market_val"] != 0]  # filter rows where valuation isnt zero
406 |         df = df.sort_values(by=['market_val_perc'], ascending=False)
407 | 
408 |         if len(df) >= 7:
409 |             # split the dataframe into two parts
410 |             df_bottom = df.tail(len(df)-6)
411 |             df = df.head(6)
412 | 
413 |             # sum the bottom dataframe to create an "Other" field
414 |             df_bottom.loc['Other'] = df_bottom.sum(numeric_only=True, axis=0)
415 |             df_bottom.at["Other", "ticker"] = "Other"
416 |             df_bottom = df_bottom.tail(1)
417 | 
418 |             df_final = pd.concat([df, df_bottom])
419 |             df_final = list(df_final.itertuples(index=False))
420 |             return df_final
421 |         else:
422 |             df_final = list(df.itertuples(index=False))
423 |             return df_final
424 | 
425 |     def get_bar_chart(self, portfolio_valuation):
426 |         """
427 |         Returns a named tuple of the 5 largest positions by absolute exposure
428 |         in descending order
429 |         """
430 |         df = portfolio_valuation.tail(1)
431 |         df = df.T.reset_index()
432 |         if df.empty:
433 |             return df
434 | 
435 |         new_headers = {df.columns[0]: "ticker", df.columns[1]: "market_val"}
436 |         df = df.rename(columns=new_headers)
437 | 
438 |         df["ticker"] = df["ticker"].replace("market_val_", "", regex=True)
439 |         # sort the dataframe by largest exposures (descending order)
440 |         df = df.iloc[df['market_val'].abs().argsort()]
441 |         df = df[df["market_val"] != 0]  # filter rows where valuation isnt zero
442 |         df = df.tail(5)  # the 5 largest positions by absolute mv
443 |         df_final = list(df.itertuples(index=False))
444 |         return df_final
445 | 


--------------------------------------------------------------------------------
/Prescient/database_tools/New_Prices.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import pandas as pd
 3 | from sqlalchemy import create_engine
 4 | 
 5 | AV_KEY = ""  # Enter your alpha vantage api key here
 6 | url = "https://www.alphavantage.co/query?"
 7 | 
 8 | 
 9 | class Price_Update(object):
10 |     """
11 |     When a user adds a new security to their watchlist a check will be
12 |     initiated to see if the security already has prices in the database.
13 |     If prices don't exist then prices for the previous 100 days will be
14 |     addded to the database.
15 |     """
16 | 
17 |     def __init__(self, ticker):
18 |         self.ticker = ticker
19 | 
20 |     def av_table(self):
21 |         parameters = {"apikey": "AV_KEY",
22 |                       "function": "TIME_SERIES_DAILY",
23 |                       "symbol": self.ticker}
24 |         response = requests.get(url, params=parameters)
25 |         response_json = response.json()
26 |         data = response_json['Time Series (Daily)']
27 | 
28 |         df = pd.DataFrame.from_dict(data,
29 |                                     orient="index",
30 |                                     columns=["4. close"])
31 |         df = df.rename(columns={"4. close": "price"})
32 |         df = df.reset_index()
33 |         return df
34 | 
35 |     def import_prices(self):
36 |         engine = create_engine("mysql://root:E6#hK-rA5!tn@localhost/prescientpricesdb")
37 |         # writes the dataframes to SQL
38 |         df = self.av_table()
39 |         df.to_sql(self.ticker, con=engine, if_exists="replace", index=False)
40 |         print(f"The Database has been updated with the table {self.ticker}")
41 | 


--------------------------------------------------------------------------------
/Prescient/database_tools/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/database_tools/__init__.py


--------------------------------------------------------------------------------
/Prescient/database_tools/csv_files/FTSE_Sectors.csv:
--------------------------------------------------------------------------------
 1 | name
 2 | Aerospace & Defence
 3 | Automobiles & Parts
 4 | Chemicals
 5 | Construction & Materials
 6 | Consumer Services
 7 | Electricity
 8 | Electronic & Electrical Equipment
 9 | Financial Services
10 | Food Producers
11 | Forestry & Paper
12 | "Gas, Water & Multi-utilities"
13 | General Industrials
14 | General Retailers
15 | Health Care Equipment & Services
16 | Household Goods & Home Construction
17 | Insurance
18 | Media
19 | Mining
20 | Oil & Gas Producers
21 | Personal Goods
22 | Pharmaceuticals & Biotechnology
23 | Real Estate Investment Trusts
24 | Retail hospitality
25 | Support Services
26 | Technology
27 | Telecommunications
28 | Tobacco
29 | Travel & Leisure
30 | 


--------------------------------------------------------------------------------
/Prescient/database_tools/load_csv_files_manual.py:
--------------------------------------------------------------------------------
 1 | import pandas as pd
 2 | import os
 3 | from sqlalchemy import create_engine
 4 | # A quick script that loads csv data to the Main DataBase
 5 | 
 6 | FILE_PATH = os.path.abspath(os.path.dirname(__file__))
 7 | engine = create_engine("mysql://root:E6#hK-rA5!tn@localhost/prescientmaindb")
 8 | 
 9 | sector_file = os.path.join(FILE_PATH, "csv_files", "FTSE_Sectors.csv")
10 | security_details = os.path.join(FILE_PATH, "csv_files", "stock_tickers_av.csv")
11 | 
12 | sectors = pd.read_csv(sector_file)
13 | tradeable_securities = pd.read_csv(security_details)
14 | 
15 | sectors.to_sql("sector_definitions",
16 |                con=engine,
17 |                if_exists="append",
18 |                index=False)
19 | 
20 | tradeable_securities.to_sql("available_securities",
21 |                             con=engine,
22 |                             if_exists="append",
23 |                             index=False)
24 | 


--------------------------------------------------------------------------------
/Prescient/database_tools/load_prices_manual.py:
--------------------------------------------------------------------------------
 1 | import pandas as pd
 2 | import requests
 3 | from sqlalchemy import create_engine
 4 | 
 5 | AV_KEY = ""  # Enter your alpha vantage api key here
 6 | url = "https://www.alphavantage.co/query?"
 7 | 
 8 | engine = create_engine("mysql://root:E6#hK-rA5!tn@localhost/prescientpricesdb")
 9 | 
10 | 
11 | class Price_Update(object):
12 | 
13 |     def __init__(self, db_tickers):
14 |         self.db_tickers = db_tickers
15 | 
16 |     def get_list(self):
17 |         if self.db_tickers == []:
18 |             raise ValueError("The list is empty")
19 |         else:
20 |             all_tickers = [ticker[0] for ticker in self.db_tickers]
21 |             return all_tickers
22 | 
23 |     def av_price(self, ticker):
24 |         parameters = {"apikey": "AV_KEY",
25 |                       "function": "TIME_SERIES_DAILY",
26 |                       "symbol": ticker}
27 |         response = requests.get(url, params=parameters)
28 |         response_json = response.json()
29 |         data = response_json['Time Series (Daily)']
30 | 
31 |         df = pd.DataFrame.from_dict(data,
32 |                                     orient="index",
33 |                                     columns=["4. close"])
34 |         df = df.rename(columns={"4. close": "price"})
35 |         df = df.reset_index()
36 |         return df
37 | 
38 |     def price_import(self):
39 |         all_tickers = self.get_list()
40 |         engine = create_engine("mysql://root:E6#hK-rA5!tn@localhost/prescientpricesdb")
41 |         # writes the dataframes to SQL
42 |         for ticker in all_tickers:
43 |             df = self.av_price(ticker)
44 |             df.to_sql(ticker, con=engine, if_exists="replace", index=False)
45 |             print(f"The database, has been updated with the table {ticker}")
46 |         print("End")
47 | 
48 | # Example on how to load prices
49 | # tickers = [("AAL", "AAL"), ("AAP", "AAP"), ("CME", "CME"), ("KO", "KO")]
50 | # prices = Price_Update(tickers)
51 | # prices.price_import()
52 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/Prescient/models/__init__.py:
--------------------------------------------------------------------------------
1 | from Prescient.models.user import User, load_user
2 | from Prescient.models.watchlist import (WatchlistItems,
3 |                                         Watchlist_Group,
4 |                                         default_date)
5 | from Prescient.models.db_securities import (Available_Securities,
6 |                                             Sector_Definitions)
7 | 


--------------------------------------------------------------------------------
/Prescient/models/db_securities.py:
--------------------------------------------------------------------------------
 1 | from Prescient import db
 2 | 
 3 | 
 4 | class Available_Securities(db.Model):
 5 |     __tablename__ = "available_securities"
 6 |     name = db.Column(db.String(70))
 7 |     ticker = db.Column(db.String(20), primary_key=True)
 8 |     country = db.Column(db.String(40))
 9 |     benchmark_index = db.Column(db.String(30))
10 |     ISO_alpha3_codes = db.Column(db.String(3))
11 | 
12 |     def __repr__(self):
13 |         return (f"<Security Name: {self.name}, "
14 |                 "Group Name: {self.ticker}, Country: {self.country}>")
15 | 
16 | 
17 | class Sector_Definitions(db.Model):
18 |     __tablename__ = "sector_definitions"
19 |     name = db.Column(db.String(70), nullable=False, primary_key=True,
20 |                      index=True)
21 | 
22 |     def __repr__(self):
23 |         return (f"<Sector Name: {self.name}>")
24 | 


--------------------------------------------------------------------------------
/Prescient/models/user.py:
--------------------------------------------------------------------------------
 1 | from Prescient import db
 2 | from Prescient import login
 3 | from flask_login import UserMixin
 4 | 
 5 | 
 6 | class User (UserMixin, db.Model):
 7 |     __tablename__ = "login_details"
 8 |     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
 9 |     username = db.Column(db.String(25), index=True, unique=True,
10 |                          nullable=False)
11 |     password = db.Column(db.String(257), nullable=False)
12 |     child1 = db.relationship('Watchlist_Group', backref='login_details',
13 |                              passive_deletes=True)
14 |     child2 = db.relationship('WatchlistItems', backref='login_details',
15 |                              passive_deletes=True)
16 | 
17 |     def __repr__(self):
18 |         return (f"<Username {self.username}>")
19 | 
20 | 
21 | @login.user_loader
22 | def load_user(id):
23 |     return User.query.get(int(id))
24 | 


--------------------------------------------------------------------------------
/Prescient/models/watchlist.py:
--------------------------------------------------------------------------------
 1 | from Prescient import db
 2 | from datetime import datetime, timedelta, date
 3 | 
 4 | 
 5 | def default_date():
 6 |     trade_date = datetime.utcnow()
 7 |     weekday = date.isoweekday(trade_date)
 8 |     # 6 = Saturday, 7 = Sunday
 9 |     if weekday == 6:
10 |         trade_date = trade_date - timedelta(days=1)
11 |     elif weekday == 7:
12 |         trade_date = trade_date - timedelta(days=2)
13 |     return trade_date
14 | 
15 | 
16 | class WatchlistItems(db.Model):
17 |     __tablename__ = "watchlist_securities"
18 |     id = db.Column(db.Integer, primary_key=True, index=True)
19 |     watchlist = db.Column(db.String(25), nullable=False)
20 |     ticker = db.Column(db.String(20), nullable=False)
21 |     quantity = db.Column(db.Integer, nullable=False)
22 |     price = db.Column(db.Float, nullable=False)
23 |     sector = db.Column(db.String(100), nullable=False)
24 |     trade_date = db.Column(db.DateTime, default=default_date)
25 |     created_timestamp = db.Column(db.DateTime, default=datetime.utcnow)
26 |     comments = db.Column(db.String(140))
27 |     user_id = db.Column(db.Integer,
28 |                         db.ForeignKey("login_details.id",
29 |                                       on_delete="CASCADE"), nullable=False)
30 |     group_id = db.Column(db.Integer,
31 |                          db.ForeignKey("watchlist_group.id",
32 |                                        on_delete="CASCADE"), nullable=False)
33 | 
34 |     def __repr__(self):
35 |         return (f"<Order ID: {self.id}, Ticker: {self.ticker}>")
36 | 
37 | 
38 | class Watchlist_Group(db.Model):
39 |     __tablename__ = "watchlist_group"
40 |     id = db.Column(db.Integer, primary_key=True)
41 |     name = db.Column(db.String(25), nullable=False)
42 |     user_id = db.Column(db.Integer,
43 |                         db.ForeignKey("login_details.id",
44 |                                       on_delete="CASCADE"), nullable=False)
45 |     child = db.relationship("WatchlistItems",
46 |                             backref="watchlist_group", passive_deletes=True)
47 | 
48 |     def __repr__(self):
49 |         return (f"<Group ID: {self.id}, Group Name: {self.name}>")
50 | 


--------------------------------------------------------------------------------
/Prescient/static/assets/finance-prescient2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/static/assets/finance-prescient2.png


--------------------------------------------------------------------------------
/Prescient/static/assets/finance-prescient2backup.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/static/assets/finance-prescient2backup.png


--------------------------------------------------------------------------------
/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/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/static/javascript/navbarscript.js:
--------------------------------------------------------------------------------
 1 | const navSlide = () => {
 2 |   const breaks = document.querySelector('.breaks');
 3 |   const nav = document.querySelector('.nav-icons');
 4 |   const navIcons = document.querySelectorAll('.nav-icons li');
 5 |   const section = document.getElementsByClassName('main-content');
 6 |   //toggle Nav
 7 |   breaks.addEventListener('click',()=>{
 8 |     nav.classList.toggle('nav-active');
 9 | 
10 |     //Animate Links
11 |     navIcons.forEach((link,index)=>{
12 |       if(link.style.animation){
13 |         link.style.animation = ``;
14 |       } else{
15 |         link.style.animation = `navLinkFade 0.5s ease forwards ${index/10+0.5}s`;
16 |       }
17 |     });
18 |     section[0].classList.toggle('main-content-active');
19 | 
20 |     // 3break lines animation
21 |     breaks.classList.toggle('toggle');
22 |   });
23 | 
24 | }
25 | 
26 | navSlide();
27 | 


--------------------------------------------------------------------------------
/Prescient/static/javascript/watchlist-all-security-filter.js:
--------------------------------------------------------------------------------
 1 | var $rows = $('#all-tradeable-securities tbody tr');
 2 | $('#filter-tradeable-securities').keyup(function() {
 3 | 
 4 |     // Regular Expression
 5 |     var val = '^(?=.*\\b' + $.trim($(this).val()).split(/\s+/).join('\\b)(?=.*\\b') + ').*$',
 6 |         reg = RegExp(val, 'i'),
 7 |         text;
 8 | 
 9 |     $rows.show().filter(function() {
10 |         text = $(this).text().replace(/\s+/g, ' ');
11 |         return !reg.test(text);
12 |     }).hide();
13 | });
14 | 


--------------------------------------------------------------------------------
/Prescient/static/javascript/watchlist-filter.js:
--------------------------------------------------------------------------------
 1 | var $rows1 = $('#all-trades tbody tr');
 2 | $('#filter').keyup(function() {
 3 | 
 4 |     // Regular Expression
 5 |     var val = '^(?=.*\\b' + $.trim($(this).val()).split(/\s+/).join('\\b)(?=.*\\b') + ').*$',
 6 |         reg = RegExp(val, 'i'),
 7 |         text;
 8 | 
 9 |     $rows1.show().filter(function() {
10 |         text = $(this).text().replace(/\s+/g, ' ');
11 |         return !reg.test(text);
12 |     }).hide();
13 | });
14 | 


--------------------------------------------------------------------------------
/Prescient/static/styles/auth-styles.css:
--------------------------------------------------------------------------------
 1 | .main-wrapper-form{
 2 |   position: relative;
 3 |   width: 500px;
 4 |   border-radius: 10px;
 5 |   border: 1px solid black;
 6 |   padding: 150px 150px 130px 100px;
 7 |   margin: 0 auto;
 8 |   background: -webkit-linear-gradient(top, #221bf5, #531cb8, #531cb8);
 9 | }
10 | 
11 | .auth-form{
12 |   margin-left: auto;
13 |   margin-right: auto;
14 |   display: inline-block;
15 |   font-size: 24px;
16 | }
17 | 
18 | .Form-title{
19 |   position: absolute;
20 |   top: 50;
21 |   left:200;
22 |   text-align: center;
23 |   font-size: 36;
24 | }
25 | 
26 | input[type=text]{
27 |   font-size: 20;
28 |   border: 1px solid grey;
29 |   border-radius: 3px;
30 |   transition-duration: 0.5s
31 | }
32 | 
33 | input[type=password]{
34 |   font-size: 20;
35 |   border: 1px solid grey;
36 |   border-radius: 3px;
37 |   transition-duration: 0.5s
38 | }
39 | 
40 | input[type=text]:focus{
41 |   border: 2px solid #19b540;
42 |   transition-duration: 0.5s
43 | }
44 | 
45 | input[type=password]:focus{
46 |   border: 2px solid #19b540;
47 |   transition-duration: 0.5s
48 | }
49 | 
50 | input[type="submit"]{
51 |   border: 1px solid #000;
52 |   border-radius: 16px;
53 |   padding: 10px;
54 |   font-size: 20px;
55 |   font-weight: bold;
56 |   cursor: pointer;
57 |   transition: 0.7s;
58 | }
59 | 
60 | .remember-text{
61 |   font-size: 12px;
62 | }
63 | 
64 | input[type="submit"]:hover{
65 |   background-color: #15d673;
66 |   transition: 0.7s;
67 | }
68 | 


--------------------------------------------------------------------------------
/Prescient/static/styles/bootstrap/bootstrap.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Generated using the Bootstrap Customizer (https://getbootstrap.com/docs/3.4/customize/)
  3 |  */
  4 | /*!
  5 |  * Bootstrap v3.4.1 (https://getbootstrap.com/)
  6 |  * Copyright 2011-2019 Twitter, Inc.
  7 |  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
  8 |  */
  9 | /*! normalize.css v3.0.3 | MIT License | github.com/necolas/normalize.css */
 10 | html {
 11 |   font-family: sans-serif;
 12 |   -ms-text-size-adjust: 100%;
 13 |   -webkit-text-size-adjust: 100%;
 14 | }
 15 | 
 16 | article,
 17 | aside,
 18 | details,
 19 | figcaption,
 20 | figure,
 21 | footer,
 22 | hgroup,
 23 | main,
 24 | menu,
 25 | summary {
 26 |   display: block;
 27 | }
 28 | audio,
 29 | canvas,
 30 | progress,
 31 | video {
 32 |   display: inline-block;
 33 |   vertical-align: baseline;
 34 | }
 35 | audio:not([controls]) {
 36 |   display: none;
 37 |   height: 0;
 38 | }
 39 | [hidden],
 40 | template {
 41 |   display: none;
 42 | }
 43 | a {
 44 |   background-color: transparent;
 45 | }
 46 | a:active,
 47 | a:hover {
 48 |   outline: 0;
 49 | }
 50 | abbr[title] {
 51 |   border-bottom: none;
 52 |   text-decoration: underline;
 53 |   text-decoration: underline dotted;
 54 | }
 55 | b,
 56 | strong {
 57 |   font-weight: bold;
 58 | }
 59 | dfn {
 60 |   font-style: italic;
 61 | }
 62 | mark {
 63 |   background: #ff0;
 64 |   color: #000;
 65 | }
 66 | small {
 67 |   font-size: 80%;
 68 | }
 69 | sub,
 70 | sup {
 71 |   font-size: 75%;
 72 |   line-height: 0;
 73 |   position: relative;
 74 |   vertical-align: baseline;
 75 | }
 76 | sup {
 77 |   top: -0.5em;
 78 | }
 79 | sub {
 80 |   bottom: -0.25em;
 81 | }
 82 | img {
 83 |   border: 0;
 84 | }
 85 | svg:not(:root) {
 86 |   overflow: hidden;
 87 | }
 88 | figure {
 89 |   margin: 1em 40px;
 90 | }
 91 | hr {
 92 |   -webkit-box-sizing: content-box;
 93 |   -moz-box-sizing: content-box;
 94 |   box-sizing: content-box;
 95 |   height: 0;
 96 | }
 97 | pre {
 98 |   overflow: auto;
 99 | }
100 | code,
101 | kbd,
102 | pre,
103 | samp {
104 |   font-family: monospace, monospace;
105 |   font-size: 1em;
106 | }
107 | button,
108 | input,
109 | optgroup,
110 | select,
111 | textarea {
112 |   color: black;
113 |   font: inherit;
114 |   margin: 0;
115 | }
116 | button {
117 |   overflow: visible;
118 | }
119 | button,
120 | select {
121 |   text-transform: none;
122 | }
123 | button,
124 | html input[type="button"],
125 | input[type="reset"],
126 | input[type="submit"] {
127 |   -webkit-appearance: button;
128 |   cursor: pointer;
129 | }
130 | button[disabled],
131 | html input[disabled] {
132 |   cursor: default;
133 | }
134 | button::-moz-focus-inner,
135 | input::-moz-focus-inner {
136 |   border: 0;
137 |   padding: 0;
138 | }
139 | input {
140 |   line-height: normal;
141 | }
142 | input[type="checkbox"],
143 | input[type="radio"] {
144 |   -webkit-box-sizing: border-box;
145 |   -moz-box-sizing: border-box;
146 |   box-sizing: border-box;
147 |   padding: 0;
148 | }
149 | input[type="number"]::-webkit-inner-spin-button,
150 | input[type="number"]::-webkit-outer-spin-button {
151 |   height: auto;
152 | }
153 | input[type="search"] {
154 |   -webkit-appearance: textfield;
155 |   -webkit-box-sizing: content-box;
156 |   -moz-box-sizing: content-box;
157 |   box-sizing: content-box;
158 | }
159 | input[type="search"]::-webkit-search-cancel-button,
160 | input[type="search"]::-webkit-search-decoration {
161 |   -webkit-appearance: none;
162 | }
163 | fieldset {
164 |   border: 1px solid #c0c0c0;
165 |   margin: 0 2px;
166 |   padding: 0.35em 0.625em 0.75em;
167 | }
168 | legend {
169 |   border: 0;
170 |   padding: 0;
171 | }
172 | textarea {
173 |   overflow: auto;
174 | }
175 | optgroup {
176 |   font-weight: bold;
177 | }
178 | 
179 | * {
180 |   -webkit-box-sizing: border-box;
181 |   -moz-box-sizing: border-box;
182 |   box-sizing: border-box;
183 | }
184 | *:before,
185 | *:after {
186 |   -webkit-box-sizing: border-box;
187 |   -moz-box-sizing: border-box;
188 |   box-sizing: border-box;
189 | }
190 | html {
191 |   font-size: 10px;
192 |   -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
193 | }
194 | body {
195 |   font-family: 'Ubuntu', sans-serif;
196 |   font-size: 14px;
197 |   line-height: 1.42857143;
198 |   color: #333333;
199 |   background-color: #ffffff;
200 | }
201 | input,
202 | button,
203 | select,
204 | textarea {
205 |   font-family: inherit;
206 |   font-size: inherit;
207 |   line-height: inherit;
208 | }
209 | a {
210 |   color: #337ab7;
211 |   text-decoration: none;
212 | }
213 | a:hover,
214 | a:focus {
215 |   color: #23527c;
216 |   text-decoration: underline;
217 | }
218 | a:focus {
219 |   outline: 5px auto -webkit-focus-ring-color;
220 |   outline-offset: -2px;
221 | }
222 | figure {
223 |   margin: 0;
224 | }
225 | img {
226 |   vertical-align: middle;
227 | }
228 | .img-responsive {
229 |   display: block;
230 |   max-width: 100%;
231 |   height: auto;
232 | }
233 | .img-rounded {
234 |   border-radius: 6px;
235 | }
236 | .img-thumbnail {
237 |   padding: 4px;
238 |   line-height: 1.42857143;
239 |   background-color: #ffffff;
240 |   border: 1px solid #dddddd;
241 |   border-radius: 4px;
242 |   -webkit-transition: all 0.2s ease-in-out;
243 |   -o-transition: all 0.2s ease-in-out;
244 |   transition: all 0.2s ease-in-out;
245 |   display: inline-block;
246 |   max-width: 100%;
247 |   height: auto;
248 | }
249 | .img-circle {
250 |   border-radius: 50%;
251 | }
252 | hr {
253 |   margin-top: 20px;
254 |   margin-bottom: 20px;
255 |   border: 0;
256 |   border-top: 1px solid #eeeeee;
257 | }
258 | .sr-only {
259 |   position: absolute;
260 |   width: 1px;
261 |   height: 1px;
262 |   padding: 0;
263 |   margin: -1px;
264 |   overflow: hidden;
265 |   clip: rect(0, 0, 0, 0);
266 |   border: 0;
267 | }
268 | .sr-only-focusable:active,
269 | .sr-only-focusable:focus {
270 |   position: static;
271 |   width: auto;
272 |   height: auto;
273 |   margin: 0;
274 |   overflow: visible;
275 |   clip: auto;
276 | }
277 | [role="button"] {
278 |   cursor: pointer;
279 | }
280 | .btn {
281 |   display: inline-block;
282 |   margin-bottom: 0;
283 |   font-weight: normal;
284 |   text-align: center;
285 |   white-space: nowrap;
286 |   vertical-align: middle;
287 |   -ms-touch-action: manipulation;
288 |   touch-action: manipulation;
289 |   cursor: pointer;
290 |   background-image: none;
291 |   border: 1px solid transparent;
292 |   padding: 6px 12px;
293 |   font-size: 14px;
294 |   line-height: 1.42857143;
295 |   border-radius: 4px;
296 |   -webkit-user-select: none;
297 |   -moz-user-select: none;
298 |   -ms-user-select: none;
299 |   user-select: none;
300 | }
301 | .btn:focus,
302 | .btn:active:focus,
303 | .btn.active:focus,
304 | .btn.focus,
305 | .btn:active.focus,
306 | .btn.active.focus {
307 |   outline: 5px auto -webkit-focus-ring-color;
308 |   outline-offset: -2px;
309 | }
310 | .btn:hover,
311 | .btn:focus,
312 | .btn.focus {
313 |   color: #333333;
314 |   text-decoration: none;
315 | }
316 | .btn:active,
317 | .btn.active {
318 |   background-image: none;
319 |   outline: 0;
320 |   -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
321 |   box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
322 | }
323 | .btn.disabled,
324 | .btn[disabled],
325 | fieldset[disabled] .btn {
326 |   cursor: not-allowed;
327 |   filter: alpha(opacity=65);
328 |   opacity: 0.65;
329 |   -webkit-box-shadow: none;
330 |   box-shadow: none;
331 | }
332 | a.btn.disabled,
333 | fieldset[disabled] a.btn {
334 |   pointer-events: none;
335 | }
336 | .btn-default {
337 |   color: #333333;
338 |   background-color: #ffffff;
339 |   border-color: #cccccc;
340 | }
341 | .btn-default:focus,
342 | .btn-default.focus {
343 |   color: #333333;
344 |   background-color: #e6e6e6;
345 |   border-color: #8c8c8c;
346 | }
347 | .btn-default:hover {
348 |   color: #333333;
349 |   background-color: #e6e6e6;
350 |   border-color: #adadad;
351 | }
352 | .btn-default:active,
353 | .btn-default.active,
354 | .open > .dropdown-toggle.btn-default {
355 |   color: #333333;
356 |   background-color: #e6e6e6;
357 |   background-image: none;
358 |   border-color: #adadad;
359 | }
360 | .btn-default:active:hover,
361 | .btn-default.active:hover,
362 | .open > .dropdown-toggle.btn-default:hover,
363 | .btn-default:active:focus,
364 | .btn-default.active:focus,
365 | .open > .dropdown-toggle.btn-default:focus,
366 | .btn-default:active.focus,
367 | .btn-default.active.focus,
368 | .open > .dropdown-toggle.btn-default.focus {
369 |   color: #333333;
370 |   background-color: #d4d4d4;
371 |   border-color: #8c8c8c;
372 | }
373 | .btn-default.disabled:hover,
374 | .btn-default[disabled]:hover,
375 | fieldset[disabled] .btn-default:hover,
376 | .btn-default.disabled:focus,
377 | .btn-default[disabled]:focus,
378 | fieldset[disabled] .btn-default:focus,
379 | .btn-default.disabled.focus,
380 | .btn-default[disabled].focus,
381 | fieldset[disabled] .btn-default.focus {
382 |   background-color: #ffffff;
383 |   border-color: #cccccc;
384 | }
385 | .btn-default .badge {
386 |   color: #ffffff;
387 |   background-color: #333333;
388 | }
389 | .btn-primary {
390 |   color: #ffffff;
391 |   background-color: #337ab7;
392 |   border-color: #2e6da4;
393 | }
394 | .btn-primary:focus,
395 | .btn-primary.focus {
396 |   color: #ffffff;
397 |   background-color: #286090;
398 |   border-color: #122b40;
399 | }
400 | .btn-primary:hover {
401 |   color: #ffffff;
402 |   background-color: #286090;
403 |   border-color: #204d74;
404 | }
405 | .btn-primary:active,
406 | .btn-primary.active,
407 | .open > .dropdown-toggle.btn-primary {
408 |   color: #ffffff;
409 |   background-color: #286090;
410 |   background-image: none;
411 |   border-color: #204d74;
412 | }
413 | .btn-primary:active:hover,
414 | .btn-primary.active:hover,
415 | .open > .dropdown-toggle.btn-primary:hover,
416 | .btn-primary:active:focus,
417 | .btn-primary.active:focus,
418 | .open > .dropdown-toggle.btn-primary:focus,
419 | .btn-primary:active.focus,
420 | .btn-primary.active.focus,
421 | .open > .dropdown-toggle.btn-primary.focus {
422 |   color: #ffffff;
423 |   background-color: #204d74;
424 |   border-color: #122b40;
425 | }
426 | .btn-primary.disabled:hover,
427 | .btn-primary[disabled]:hover,
428 | fieldset[disabled] .btn-primary:hover,
429 | .btn-primary.disabled:focus,
430 | .btn-primary[disabled]:focus,
431 | fieldset[disabled] .btn-primary:focus,
432 | .btn-primary.disabled.focus,
433 | .btn-primary[disabled].focus,
434 | fieldset[disabled] .btn-primary.focus {
435 |   background-color: #337ab7;
436 |   border-color: #2e6da4;
437 | }
438 | .btn-primary .badge {
439 |   color: #337ab7;
440 |   background-color: #ffffff;
441 | }
442 | .btn-success {
443 |   color: #ffffff;
444 |   background-color: #5cb85c;
445 |   border-color: #4cae4c;
446 | }
447 | .btn-success:focus,
448 | .btn-success.focus {
449 |   color: #ffffff;
450 |   background-color: #449d44;
451 |   border-color: #255625;
452 | }
453 | .btn-success:hover {
454 |   color: #ffffff;
455 |   background-color: #449d44;
456 |   border-color: #398439;
457 | }
458 | .btn-success:active,
459 | .btn-success.active,
460 | .open > .dropdown-toggle.btn-success {
461 |   color: #ffffff;
462 |   background-color: #449d44;
463 |   background-image: none;
464 |   border-color: #398439;
465 | }
466 | .btn-success:active:hover,
467 | .btn-success.active:hover,
468 | .open > .dropdown-toggle.btn-success:hover,
469 | .btn-success:active:focus,
470 | .btn-success.active:focus,
471 | .open > .dropdown-toggle.btn-success:focus,
472 | .btn-success:active.focus,
473 | .btn-success.active.focus,
474 | .open > .dropdown-toggle.btn-success.focus {
475 |   color: #ffffff;
476 |   background-color: #398439;
477 |   border-color: #255625;
478 | }
479 | .btn-success.disabled:hover,
480 | .btn-success[disabled]:hover,
481 | fieldset[disabled] .btn-success:hover,
482 | .btn-success.disabled:focus,
483 | .btn-success[disabled]:focus,
484 | fieldset[disabled] .btn-success:focus,
485 | .btn-success.disabled.focus,
486 | .btn-success[disabled].focus,
487 | fieldset[disabled] .btn-success.focus {
488 |   background-color: #5cb85c;
489 |   border-color: #4cae4c;
490 | }
491 | .btn-success .badge {
492 |   color: #5cb85c;
493 |   background-color: #ffffff;
494 | }
495 | .btn-info {
496 |   color: #ffffff;
497 |   background-color: #5bc0de;
498 |   border-color: #46b8da;
499 | }
500 | .btn-info:focus,
501 | .btn-info.focus {
502 |   color: #ffffff;
503 |   background-color: #31b0d5;
504 |   border-color: #1b6d85;
505 | }
506 | .btn-info:hover {
507 |   color: #ffffff;
508 |   background-color: #31b0d5;
509 |   border-color: #269abc;
510 | }
511 | .btn-info:active,
512 | .btn-info.active,
513 | .open > .dropdown-toggle.btn-info {
514 |   color: #ffffff;
515 |   background-color: #31b0d5;
516 |   background-image: none;
517 |   border-color: #269abc;
518 | }
519 | .btn-info:active:hover,
520 | .btn-info.active:hover,
521 | .open > .dropdown-toggle.btn-info:hover,
522 | .btn-info:active:focus,
523 | .btn-info.active:focus,
524 | .open > .dropdown-toggle.btn-info:focus,
525 | .btn-info:active.focus,
526 | .btn-info.active.focus,
527 | .open > .dropdown-toggle.btn-info.focus {
528 |   color: #ffffff;
529 |   background-color: #269abc;
530 |   border-color: #1b6d85;
531 | }
532 | .btn-info.disabled:hover,
533 | .btn-info[disabled]:hover,
534 | fieldset[disabled] .btn-info:hover,
535 | .btn-info.disabled:focus,
536 | .btn-info[disabled]:focus,
537 | fieldset[disabled] .btn-info:focus,
538 | .btn-info.disabled.focus,
539 | .btn-info[disabled].focus,
540 | fieldset[disabled] .btn-info.focus {
541 |   background-color: #5bc0de;
542 |   border-color: #46b8da;
543 | }
544 | .btn-info .badge {
545 |   color: #5bc0de;
546 |   background-color: #ffffff;
547 | }
548 | .btn-warning {
549 |   color: #ffffff;
550 |   background-color: #f0ad4e;
551 |   border-color: #eea236;
552 | }
553 | .btn-warning:focus,
554 | .btn-warning.focus {
555 |   color: #ffffff;
556 |   background-color: #ec971f;
557 |   border-color: #985f0d;
558 | }
559 | .btn-warning:hover {
560 |   color: #ffffff;
561 |   background-color: #ec971f;
562 |   border-color: #d58512;
563 | }
564 | .btn-warning:active,
565 | .btn-warning.active,
566 | .open > .dropdown-toggle.btn-warning {
567 |   color: #ffffff;
568 |   background-color: #ec971f;
569 |   background-image: none;
570 |   border-color: #d58512;
571 | }
572 | .btn-warning:active:hover,
573 | .btn-warning.active:hover,
574 | .open > .dropdown-toggle.btn-warning:hover,
575 | .btn-warning:active:focus,
576 | .btn-warning.active:focus,
577 | .open > .dropdown-toggle.btn-warning:focus,
578 | .btn-warning:active.focus,
579 | .btn-warning.active.focus,
580 | .open > .dropdown-toggle.btn-warning.focus {
581 |   color: #ffffff;
582 |   background-color: #d58512;
583 |   border-color: #985f0d;
584 | }
585 | .btn-warning.disabled:hover,
586 | .btn-warning[disabled]:hover,
587 | fieldset[disabled] .btn-warning:hover,
588 | .btn-warning.disabled:focus,
589 | .btn-warning[disabled]:focus,
590 | fieldset[disabled] .btn-warning:focus,
591 | .btn-warning.disabled.focus,
592 | .btn-warning[disabled].focus,
593 | fieldset[disabled] .btn-warning.focus {
594 |   background-color: #f0ad4e;
595 |   border-color: #eea236;
596 | }
597 | .btn-warning .badge {
598 |   color: #f0ad4e;
599 |   background-color: #ffffff;
600 | }
601 | .btn-danger {
602 |   color: #ffffff;
603 |   background-color: #d9534f;
604 |   border-color: #d43f3a;
605 | }
606 | .btn-danger:focus,
607 | .btn-danger.focus {
608 |   color: #ffffff;
609 |   background-color: #c9302c;
610 |   border-color: #761c19;
611 | }
612 | .btn-danger:hover {
613 |   color: #ffffff;
614 |   background-color: #c9302c;
615 |   border-color: #ac2925;
616 | }
617 | .btn-danger:active,
618 | .btn-danger.active,
619 | .open > .dropdown-toggle.btn-danger {
620 |   color: #ffffff;
621 |   background-color: #c9302c;
622 |   background-image: none;
623 |   border-color: #ac2925;
624 | }
625 | .btn-danger:active:hover,
626 | .btn-danger.active:hover,
627 | .open > .dropdown-toggle.btn-danger:hover,
628 | .btn-danger:active:focus,
629 | .btn-danger.active:focus,
630 | .open > .dropdown-toggle.btn-danger:focus,
631 | .btn-danger:active.focus,
632 | .btn-danger.active.focus,
633 | .open > .dropdown-toggle.btn-danger.focus {
634 |   color: #ffffff;
635 |   background-color: #ac2925;
636 |   border-color: #761c19;
637 | }
638 | .btn-danger.disabled:hover,
639 | .btn-danger[disabled]:hover,
640 | fieldset[disabled] .btn-danger:hover,
641 | .btn-danger.disabled:focus,
642 | .btn-danger[disabled]:focus,
643 | fieldset[disabled] .btn-danger:focus,
644 | .btn-danger.disabled.focus,
645 | .btn-danger[disabled].focus,
646 | fieldset[disabled] .btn-danger.focus {
647 |   background-color: #d9534f;
648 |   border-color: #d43f3a;
649 | }
650 | .btn-danger .badge {
651 |   color: #d9534f;
652 |   background-color: #ffffff;
653 | }
654 | .btn-link {
655 |   font-weight: 400;
656 |   color: #337ab7;
657 |   border-radius: 0;
658 | }
659 | .btn-link,
660 | .btn-link:active,
661 | .btn-link.active,
662 | .btn-link[disabled],
663 | fieldset[disabled] .btn-link {
664 |   background-color: transparent;
665 |   -webkit-box-shadow: none;
666 |   box-shadow: none;
667 | }
668 | .btn-link,
669 | .btn-link:hover,
670 | .btn-link:focus,
671 | .btn-link:active {
672 |   border-color: transparent;
673 | }
674 | .btn-link:hover,
675 | .btn-link:focus {
676 |   color: #23527c;
677 |   text-decoration: underline;
678 |   background-color: transparent;
679 | }
680 | .btn-link[disabled]:hover,
681 | fieldset[disabled] .btn-link:hover,
682 | .btn-link[disabled]:focus,
683 | fieldset[disabled] .btn-link:focus {
684 |   color: #777777;
685 |   text-decoration: none;
686 | }
687 | .btn-lg {
688 |   padding: 10px 16px;
689 |   font-size: 18px;
690 |   line-height: 1.3333333;
691 |   border-radius: 6px;
692 | }
693 | .btn-sm {
694 |   padding: 5px 10px;
695 |   font-size: 12px;
696 |   line-height: 1.5;
697 |   border-radius: 3px;
698 | }
699 | .btn-xs {
700 |   padding: 1px 5px;
701 |   font-size: 12px;
702 |   line-height: 1.5;
703 |   border-radius: 3px;
704 | }
705 | .btn-block {
706 |   display: block;
707 |   width: 100%;
708 | }
709 | .btn-block + .btn-block {
710 |   margin-top: 5px;
711 | }
712 | input[type="submit"].btn-block,
713 | input[type="reset"].btn-block,
714 | input[type="button"].btn-block {
715 |   width: 100%;
716 | }
717 | .fade {
718 |   opacity: 0;
719 |   -webkit-transition: opacity 0.15s linear;
720 |   -o-transition: opacity 0.15s linear;
721 |   transition: opacity 0.15s linear;
722 | }
723 | .fade.in {
724 |   opacity: 1;
725 | }
726 | .collapse {
727 |   display: none;
728 | }
729 | .collapse.in {
730 |   display: block;
731 | }
732 | 
733 | .collapsing {
734 |   position: relative;
735 |   height: 0;
736 |   overflow: hidden;
737 |   -webkit-transition-property: height, visibility;
738 |   -o-transition-property: height, visibility;
739 |   transition-property: height, visibility;
740 |   -webkit-transition-duration: 0.35s;
741 |   -o-transition-duration: 0.35s;
742 |   transition-duration: 0.35s;
743 |   -webkit-transition-timing-function: ease;
744 |   -o-transition-timing-function: ease;
745 |   transition-timing-function: ease;
746 | }
747 | .close {
748 |   float: right;
749 |   font-size: 21px;
750 |   font-weight: bold;
751 |   line-height: 1;
752 |   color: #000000;
753 |   text-shadow: 0 1px 0 #ffffff;
754 |   filter: alpha(opacity=20);
755 |   opacity: 0.2;
756 | }
757 | .close:hover,
758 | .close:focus {
759 |   color: #000000;
760 |   text-decoration: none;
761 |   cursor: pointer;
762 |   filter: alpha(opacity=50);
763 |   opacity: 0.5;
764 | }
765 | button.close {
766 |   padding: 0;
767 |   cursor: pointer;
768 |   background: transparent;
769 |   border: 0;
770 |   -webkit-appearance: none;
771 |   appearance: none;
772 | }
773 | .modal-open {
774 |   overflow: hidden;
775 | }
776 | .modal {
777 |   position: fixed;
778 |   top: 0;
779 |   right: 0;
780 |   bottom: 0;
781 |   left: 0;
782 |   z-index: 1050;
783 |   display: none;
784 |   overflow: hidden;
785 |   -webkit-overflow-scrolling: touch;
786 |   outline: 0;
787 | }
788 | .modal.fade .modal-dialog {
789 |   -webkit-transform: translate(0, -25%);
790 |   -ms-transform: translate(0, -25%);
791 |   -o-transform: translate(0, -25%);
792 |   transform: translate(0, -25%);
793 |   -webkit-transition: -webkit-transform 0.3s ease-out;
794 |   -o-transition: -o-transform 0.3s ease-out;
795 |   transition: transform 0.3s ease-out;
796 | }
797 | .modal.in .modal-dialog {
798 |   -webkit-transform: translate(0, 0);
799 |   -ms-transform: translate(0, 0);
800 |   -o-transform: translate(0, 0);
801 |   transform: translate(0, 0);
802 | }
803 | .modal-open .modal {
804 |   overflow-x: hidden;
805 |   overflow-y: auto;
806 | }
807 | .modal-dialog {
808 |   position: relative;
809 |   width: auto;
810 |   margin: 10px;
811 | }
812 | .modal-content {
813 |   position: relative;
814 |   -webkit-background-clip: padding-box;
815 |   background-clip: padding-box;
816 |   border: 1px solid #999999;
817 |   border: 1px solid rgba(0, 0, 0, 0.2);
818 |   border-radius: 6px;
819 |   -webkit-box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);
820 |   box-shadow: 0 3px 9px rgba(0, 0, 0, 0.5);
821 |   outline: 0;
822 | }
823 | .modal-backdrop {
824 |   position: fixed;
825 |   top: 0;
826 |   right: 0;
827 |   bottom: 0;
828 |   left: 0;
829 |   z-index: 1040;
830 |   background-color: #000000;
831 | }
832 | .modal-backdrop.fade {
833 |   filter: alpha(opacity=0);
834 |   opacity: 0;
835 | }
836 | .modal-backdrop.in {
837 |   filter: alpha(opacity=50);
838 |   opacity: 0.5;
839 | }
840 | .modal-header {
841 |   padding: 15px;
842 |   background-color: rgba(48, 24, 84, 0.9);
843 |   border-bottom: 2px solid #e5e5e5;
844 | }
845 | .modal-header .close {
846 |   margin-top: -2px;
847 | }
848 | .modal-title {
849 |   margin: 0;
850 |   font-size: 14;
851 |   line-height: 1.42857143;
852 | }
853 | .modal-body {
854 |   position: relative;
855 |   padding: 15px;
856 |   background-color: rgba(23, 50, 61, 0.98);
857 | }
858 | .modal-footer {
859 |   padding: 15px;
860 |   text-align: right;
861 |   border-top: 1px solid #e5e5e5;
862 | }
863 | .modal-footer .btn + .btn {
864 |   margin-bottom: 0;
865 |   margin-left: 5px;
866 | }
867 | .modal-footer .btn-group .btn + .btn {
868 |   margin-left: -1px;
869 | }
870 | .modal-footer .btn-block + .btn-block {
871 |   margin-left: 0;
872 | }
873 | .modal-scrollbar-measure {
874 |   position: absolute;
875 |   top: -9999px;
876 |   width: 50px;
877 |   height: 50px;
878 |   overflow: scroll;
879 | }
880 | @media (min-width: 768px) {
881 |   .modal-dialog {
882 |     width: 600px;
883 |     margin: 30px auto;
884 |   }
885 |   .modal-content {
886 |     -webkit-box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);
887 |     box-shadow: 0 5px 15px rgba(0, 0, 0, 0.5);
888 |   }
889 |   .modal-sm {
890 |     width: 300px;
891 |   }
892 | }
893 | @media (min-width: 992px) {
894 |   .modal-lg {
895 |     width: 900px;
896 |   }
897 | }
898 | .clearfix:before,
899 | .clearfix:after,
900 | .modal-header:before,
901 | .modal-header:after,
902 | .modal-footer:before,
903 | .modal-footer:after {
904 |   display: table;
905 |   content: " ";
906 | }
907 | .clearfix:after,
908 | .modal-header:after,
909 | .modal-footer:after {
910 |   clear: both;
911 | }
912 | .center-block {
913 |   display: block;
914 |   margin-right: auto;
915 |   margin-left: auto;
916 | }
917 | .pull-right {
918 |   float: right !important;
919 | }
920 | .pull-left {
921 |   float: left !important;
922 | }
923 | .hide {
924 |   display: none !important;
925 | }
926 | .show {
927 |   display: block !important;
928 | }
929 | .invisible {
930 |   visibility: hidden;
931 | }
932 | .text-hide {
933 |   font: 0/0 a;
934 |   color: transparent;
935 |   text-shadow: none;
936 |   background-color: transparent;
937 |   border: 0;
938 | }
939 | .hidden {
940 |   display: none !important;
941 | }
942 | .affix {
943 |   position: fixed;
944 | }
945 | 


--------------------------------------------------------------------------------
/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/styles/performance-styles.css:
--------------------------------------------------------------------------------
  1 | .main-heading{
  2 |   text-align: center;
  3 |   color: white;
  4 |   font-size: 30px;
  5 | }
  6 | 
  7 | .main-wrapper{
  8 |   width: 100%;
  9 |   display: grid;
 10 |   grid-template-columns: 1fr 1fr;
 11 |   grid-template-rows: 1fr;
 12 |   grid-column-gap: 1px;
 13 |   grid-row-gap: 1px;
 14 |   min-width: 0;
 15 |   min-height: 0;
 16 | }
 17 | 
 18 | @media screen and (max-width: 1000px) {
 19 |   .main-wrapper{
 20 |     display: block;
 21 |   }
 22 | }
 23 | 
 24 | table {
 25 |  margin-left: auto;
 26 |  margin-right: auto;
 27 |  width: 500px;
 28 |  border-collapse: collapse;
 29 |  box-shadow: 0 0 20px rgba(0, 0, 0, 0.0);
 30 |  border-radius: 5px;
 31 | }
 32 | 
 33 | td {
 34 |   padding: 15px;
 35 |   background-color: rgba(0, 0, 0, 0.1);
 36 |   color: #4ed48a;
 37 | }
 38 | 
 39 | th {
 40 |   text-align: left;
 41 |   font-weight: bolder;
 42 |   padding: 15px;
 43 | }
 44 | 
 45 | thead {
 46 |   background-color: rgba(27, 97, 1, 0.3);
 47 |   color: white;
 48 |   border: 1px solid #27db2a;
 49 | }
 50 | 
 51 | tbody {
 52 |   background-color: rgba(0, 0, 0, 0.2);
 53 |   border: 1px solid #27db2a;
 54 | }
 55 | 
 56 | .table-container{
 57 |   overflow-y: auto;
 58 |   height: 50vh;
 59 | }
 60 | 
 61 | .table-container thead, th{
 62 |   color: white;
 63 |   padding: 15px;
 64 | }
 65 | 
 66 | .watchlist-rows{
 67 |   transition: 0.2s
 68 | }
 69 | 
 70 | .watchlist-rows:hover{
 71 |   background-color: #40888f;
 72 | }
 73 | 
 74 | .watchlist-name-title{
 75 |   color: #6397ff;
 76 |   font-weight: bolder;
 77 |   font-size: 40px;
 78 | }
 79 | 
 80 | .watchlist-name-ticker{
 81 |   color: #2ed95b;
 82 |   font-weight: bolder;
 83 |   font-size: 35px;
 84 | }
 85 | 
 86 | .btn-select{
 87 |   color:black;
 88 |   border-radius: 5px;
 89 |   border: 1px solid #02610f;
 90 |   border-radius: 8px;
 91 |   padding: 5px;
 92 |   font-size: 14px;
 93 |   font-weight: bold;
 94 |   cursor: pointer;
 95 |   transition: 0.7s;
 96 | }
 97 | 
 98 | .btn-select:hover{
 99 |   background-color: #02610f;
100 |   color: white;
101 |   transition: 0.7s;
102 | }
103 | 
104 | .Welcome2{
105 |   text-align: center;
106 |   position: absolute;
107 |   top: 50%;
108 |   left: 50%;
109 |   transform: translate(-50%, -50%);
110 |   color: white;
111 | }
112 | 
113 | .main-heading2{
114 |   font-size: 30px;
115 | }
116 | 
117 | .to-watchlist-link {
118 |   text-decoration: none;
119 |   list-style-type: none;
120 | }
121 | 
122 | .to-watchlist-link a{
123 |   transition: 0.3s;
124 |   color: #43a1e8;
125 |   border-bottom: #46eb7a 1px solid;
126 |   text-decoration: none;
127 |   list-style-type: none;
128 | }
129 | 
130 | .to-watchlist-link a:hover{
131 |   transition: 0.3s;
132 |   font-weight: bold;
133 |   border-bottom: #46eb7a 2px solid;
134 | }
135 | 


--------------------------------------------------------------------------------
/Prescient/static/styles/watchlist-styles.css:
--------------------------------------------------------------------------------
  1 | table {
  2 |  margin-left: auto;
  3 |  margin-right: auto;
  4 |  width: 500px;
  5 |  border-collapse: collapse;
  6 |  overflow: hidden;
  7 |  box-shadow: 0 0 20px rgba(0, 0, 0, 0.0);
  8 |  border-radius: 5px;
  9 | }
 10 | 
 11 | td {
 12 |   padding: 15px;
 13 |   background-color: rgba(0, 0, 0, 0.1);
 14 |   color: #B3E5FC;
 15 | }
 16 | 
 17 | th {
 18 |   text-align: left;
 19 |   font-weight: bolder;
 20 |   padding: 15px;
 21 | }
 22 | 
 23 | thead {
 24 |   background-color: rgba(30, 90, 252, 0.3);
 25 |   color: white;
 26 |   border: 2px solid #B3E5FC;
 27 | }
 28 | 
 29 | tbody {
 30 |   background-color: rgba(0, 0, 0, 0.2);
 31 |   border: 2px solid #B3E5FC;
 32 | }
 33 | 
 34 | .watchlist-rows{
 35 |   transition: 0.2s
 36 | }
 37 | 
 38 | .watchlist-rows:hover{
 39 |   background-color: #40888f;
 40 | }
 41 | 
 42 | .summary-table-container{
 43 |   height: 42vh;
 44 |   overflow-y: scroll;
 45 | }
 46 | 
 47 | .all-trades{
 48 |   width: 90%;
 49 | }
 50 | 
 51 | .main-heading{
 52 |   text-align: center;
 53 |   font-size: 30px;
 54 | }
 55 | 
 56 | .action{
 57 |   color:white;
 58 |   border-radius: 5px;
 59 |   background-color: black;
 60 |   padding: 2px;
 61 | }
 62 | 
 63 | .btn-new-wl{
 64 |   color:black;
 65 |   border-radius: 5px;
 66 |   border: 2px solid #081682;
 67 |   border-radius: 8px;
 68 |   padding: 5px;
 69 |   font-size: 14px;
 70 |   font-weight: bold;
 71 |   cursor: pointer;
 72 |   transition: 0.7s;
 73 | }
 74 | 
 75 | .btn-new-wl-item{
 76 |   color:black;
 77 |   border-radius: 5px;
 78 |   border: 2px solid #081682;
 79 |   border-radius: 8px;
 80 |   padding: 5px;
 81 |   font-size: 14px;
 82 |   font-weight: bold;
 83 |   cursor: pointer;
 84 |   transition: 0.7s;
 85 |   margin-left: 70px;
 86 | }
 87 | 
 88 | .btn-new-wl-item:hover{
 89 |   background-color: #081682;
 90 |   color: white;
 91 |   transition: 0.7s;
 92 | }
 93 | 
 94 | .btn-new-wl:hover{
 95 |   background-color: #081682;
 96 |   color: white;
 97 |   transition: 0.7s;
 98 | }
 99 | 
100 | .selection-label{
101 |   margin-left: 70px;
102 | }
103 | 
104 | .danger{
105 |   color:black;
106 |   border-radius: 5px;
107 |   border: 2px solid #081682;
108 |   border-radius: 8px;
109 |   padding: 5px;
110 |   font-size: 14px;
111 |   font-weight: bold;
112 |   cursor: pointer;
113 |   transition: 0.7s;
114 | }
115 | 
116 | .danger:hover{
117 |   background-color: #081682;
118 |   color: white;
119 |   transition: 0.7s;
120 | }
121 | 
122 | .watchlist-name-title{
123 |   color: #6397ff;
124 |   font-weight: bolder;
125 |   font-size: 40px;
126 | }
127 | 
128 | .filter-bar {
129 |   border-radius: 8px;
130 | }
131 | 
132 | .filter-bar2 {
133 |   border-radius: 8px;
134 | }
135 | 
136 | .all-securities-table-container{
137 |   height: 70vh;
138 |   overflow-y: scroll;
139 | }
140 | .security-rows{
141 |   transition: 0.2s
142 | }
143 | 
144 | .security-rows:hover{
145 |   background-color: #40888f;
146 | }
147 | 
148 | .Welcome2{
149 |   text-align: center;
150 |   position: absolute;
151 |   top: 50%;
152 |   left: 50%;
153 |   transform: translate(-50%, -50%);
154 |   color: white;
155 | }
156 | 
157 | .main-heading2{
158 |   font-size: 30px;
159 | }
160 | 
161 | .create-watchlist {
162 |   text-decoration: none;
163 |   list-style-type: none;
164 |   font-size: 20px;
165 | }
166 | 
167 | .create-watchlist a{
168 |   transition: 0.3s;
169 |   color: #43a1e8;
170 |   border-bottom: #46eb7a 1px solid;
171 |   text-decoration: none;
172 |   list-style-type: none;
173 | }
174 | 
175 | .create-watchlist a:hover{
176 |   transition: 0.3s;
177 |   font-weight: bold;
178 |   border-bottom: #46eb7a 2px solid;
179 | }
180 | 


--------------------------------------------------------------------------------
/Prescient/templates/_formhelpers.html:
--------------------------------------------------------------------------------
 1 | {% macro render_field(field) %}
 2 | <dt>{{ field.label }}
 3 | <dd>{{ field(**kwargs)|safe }}
 4 | {% if field.errors %}
 5 |   <ul class=errors>
 6 |   {% for error in field.errors %}
 7 |     <li>{{ error }}</li>
 8 |   {% endfor %}
 9 |   </ul>
10 | {% endif %}
11 | </dd>
12 | {% endmacro %}
13 | 


--------------------------------------------------------------------------------
/Prescient/templates/auth/login.html:
--------------------------------------------------------------------------------
 1 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/auth-styles.css') }}">
 2 | {% extends 'base_layout.html' %}
 3 | 
 4 | {% block header %}
 5 |   <h1>{% block title %}{% endblock %}</h1>
 6 | {% endblock %}
 7 | 
 8 | {% block content %}
 9 | <br>
10 | <div class="main-wrapper-form">
11 |   <h1 class="Form-title">Log In</h1>
12 |   {% from "_formhelpers.html" import render_field %}
13 |   <form action="{{ url_for('auth.login') }}" method="post" class="auth-form">
14 |     <dl>
15 |       {{ render_field(form.username) }}
16 |       {{ render_field(form.password) }}
17 |       <span class="remember-text">{{ render_field(form.remember_me) }}</span>
18 |     </dl>
19 |     <p>{{ form.submit() }}</p>
20 |     {{ form.csrf_token }}
21 |   </form>
22 | 
23 | </div>
24 | {% endblock %}
25 | 


--------------------------------------------------------------------------------
/Prescient/templates/auth/register.html:
--------------------------------------------------------------------------------
 1 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/auth-styles.css') }}">
 2 | {% extends 'base_layout.html' %}
 3 | 
 4 | {% block header %}
 5 |   <h1>{% block title %}{% endblock %}</h1>
 6 | {% endblock %}
 7 | 
 8 | {% block content %}
 9 | <br>
10 | <div class="main-wrapper-form">
11 |   <h1 class="Form-title">Register</h1>
12 |   {% from "_formhelpers.html" import render_field %}
13 |   <form method=post class="auth-form">
14 |     <dl>
15 |       {{ render_field(form.username) }}
16 |       {{ render_field(form.password) }}
17 |       {{ render_field(form.confirm) }}
18 |     </dl>
19 |     <br>
20 |     <p>{{ form.submit() }}</p>
21 |     {{ form.csrf_token }}
22 |   </form>
23 | </div>
24 | {% endblock %}
25 | 


--------------------------------------------------------------------------------
/Prescient/templates/base_layout.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <head>
 3 |   <meta charset="utf-8">
 4 |   <meta name="viewport" content="width=device-width, initial-scale=1.0">
 5 |   <link href="https://fonts.googleapis.com/css?family=Ubuntu&display=swap" rel="stylesheet">
 6 |   <link href="https://fonts.googleapis.com/css?family=Open+Sans&display=swap" rel="stylesheet">
 7 |   <link rel="stylesheet" href="{{ url_for('static', filename='base_style.css') }}">
 8 |   <title>Prescient Finance</title>
 9 | </head>
10 | <title>{% block title %}Prescient{% endblock %}</title>
11 | <body>
12 |   <nav>
13 |     <div class="breaks">
14 |       <div class="bk1"></div>
15 |       <div class="bk2"></div>
16 |       <div class="bk3"></div>
17 |     </div>
18 |     <div class="Logo">
19 |       <a href="{{ url_for('dashboard.index') }}"><img src="{{ url_for('static', filename='assets/finance-prescient2.png') }}" alt="Prescient Finance"></a>
20 |     </div>
21 |     <ul class="nav-icons">
22 |       {% if current_user.is_authenticated %}
23 |         <li><span class="username">{{ current_user.username }}</span></li>
24 |       {% endif %}
25 |       <li><a href="{{ url_for('dashboard.index') }}">DASHBOARD</a></li>
26 |       <li><a href="{{ url_for('charts.chart_breakdown') }}">CHARTS</a></li>
27 |       <li><a href="{{ url_for('watchlist.main') }}">WATCHLIST</a></li>
28 |       {% if current_user.is_authenticated %}
29 |         <li><a href="{{ url_for('auth.logout') }}">Log Out</a></li>
30 |       {% else %}
31 |         <li><a href="{{ url_for('auth.register') }}">Register</a></li>
32 |         <li><a href="{{ url_for('auth.login') }}">Log In</a></li>
33 |       {% endif %}
34 |     </ul>
35 |   </nav>
36 |   <script src="{{ url_for('static', filename='javascript/navbarscript.js') }}"></script>
37 | </body>
38 | <section class="main-content">
39 |   <header>
40 |     {% block header %}{% endblock %}
41 |   </header>
42 |   {% for message in get_flashed_messages() %}
43 |     <div class="flash">{{ message }}</div>
44 |   {% endfor %}
45 |   {% block content %}{% endblock %}
46 | </section>
47 | 


--------------------------------------------------------------------------------
/Prescient/templates/charts/performance_breakdown.html:
--------------------------------------------------------------------------------
  1 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/performance-styles.css') }}">
  2 | <script src=https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.9.3/Chart.min.js></script>
  3 | {% extends 'base_layout.html' %}
  4 | 
  5 | {% block header %}
  6 | {% if group_name is defined and selected_ticker is not none %}
  7 |   <h1 class="main-heading">{% block title %}<span class="watchlist-name-title">{{group_name}}</span> Performance Breakdown for <span class="watchlist-name-ticker">{{selected_ticker}}</span> {% endblock %}</h1>
  8 |   <br>
  9 | {% elif group_name is not none and selected_ticker is none%}
 10 |   <div class="Welcome2">
 11 |     <h1 class="main-heading2"><span class="watchlist-name-title">{{group_name}}</span> does not have any trade history</h1>
 12 |     <li class="to-watchlist-link"><a href="{{ url_for('watchlist.main') }}">Add some securities here</a></li>
 13 |   </div>
 14 | {% else %}
 15 |   <div class="Welcome2">
 16 |     <h1 class="main-heading2"> You do not have any active watchlists.</h1>
 17 |     <li class="to-watchlist-link"><a href="{{ url_for('watchlist.main') }}">Create a watchlist here</a></li>
 18 |   </div>
 19 | {% endif %}
 20 | {% endblock %}
 21 | 
 22 | {% block content %}
 23 | {% if group_name is defined and selected_ticker is not none %}
 24 |   <form class="group-selection" action="{{url_for('charts.chart_breakdown')}}" method="post">
 25 |     <span class="selection-label">Select a Watchlist</span>
 26 |     <select class="watchlist-selector" name="watchlist_group_selection">
 27 |       {% for watchlist_name in user_watchlists %}
 28 |       <option value="{{watchlist_name}}">{{watchlist_name}}</option>
 29 |       {% endfor %}
 30 |     </select>
 31 |     <button type="submit" name="btn_btn_default" class="btn-select">Get overview</button>
 32 |   </form>
 33 |   <div class="main-wrapper">
 34 |     <div class="table-container">
 35 |       <table>
 36 |         <thead>
 37 |           <tr>
 38 |             <th>Date</th>
 39 |             <th>Quantity</th>
 40 |             <th>Average Cost</th>
 41 |             <th>Price</th>
 42 |             <th>Unrealised P&L</th>
 43 |           </tr>
 44 |         </thead>
 45 |         <tbody>
 46 |           {% for item in breakdown %}
 47 |           <tr class="watchlist-rows">
 48 |             <td class="c2">{{item.date}}</td>
 49 |             <td class="c9">{{item.quantity}}</td>
 50 |             <td class="c2">{{item.avg_cost}}</td>
 51 |             <td class="c3">{{item.price}}</td>
 52 |             <td class="c3">{{item.pct_change}}%</td>
 53 |           </tr>
 54 |           {% endfor %}
 55 |         </tbody>
 56 |       </table>
 57 |     </div>
 58 |     <div class="line-chart-container">
 59 |       <canvas id="myChart"></canvas>
 60 |     </div>
 61 |     <script>
 62 |     //Chart.defaults.global.responsive = false;
 63 |     var ctx = document.getElementById('myChart');
 64 |     var myChart = new Chart(ctx, {
 65 |         type: 'line',
 66 |         tooltipCaretSize: 10,
 67 |         maintainAspectRatio: false,
 68 |         data: {
 69 |             labels: [{% for item in line_chart %}
 70 |             "{{item.date}}",
 71 |             {% endfor %}],
 72 |             datasets: [{
 73 |                 label: '%',
 74 |                 data: [{% for item in line_chart %}
 75 |                 "{{item.pct_change}}",
 76 |                 {% endfor %}],
 77 |                 backgroundColor: [
 78 |                     'rgba(94, 255, 137, 0.2)'
 79 |                 ],
 80 |                 borderColor: [{% for item in line_chart %}
 81 |                     'rgba(5, 38, 14, 1)',
 82 |                     {% endfor %}
 83 |                 ],
 84 |                 borderWidth: 2,
 85 |                 pointBorderWidth: 1,
 86 |                 pointBorderColor: 'rgba(40, 106, 176, 1)'
 87 |             }]
 88 |         },
 89 |         options: {
 90 |           responsive:true,
 91 |           tooltips: {
 92 |             mode: "index",
 93 |             intersect:false,
 94 |           },
 95 |           hover:{
 96 |             mode: "nearest",
 97 |             intersect: true,
 98 |           },
 99 |           legend: {
100 |             display: false,
101 |             labels: {
102 |               fontColor: "#d4eaff"
103 |             }
104 |           },
105 |           title: {
106 |             display: true,
107 |             text: "{{selected_ticker}} Performance for {{group_name}}",
108 |             fontColor: "#2ed95b"
109 |           },
110 |           layout: {
111 |             padding:{
112 |               left: 20,
113 |               right: 20,
114 |               top: 0,
115 |               bottom: 0
116 |             }
117 |           },
118 |             scales: {
119 |                 xAxes: [{
120 |                   scaleLabel:{
121 |                     display: true,
122 |                     labelString: "Date",
123 |                     fontColor: "#2ed95b"
124 |                   },
125 |                     ticks: {
126 |                         fontColor: "#d4eaff",
127 |                         autoSkip: true,
128 |                         maxTicksLimit: 6,
129 |                         maxRotation: 15,
130 |                         minRotation:15
131 |                     }
132 |                 }],
133 |                 yAxes: [{
134 |                   display:true,
135 |                   scaleLabel:{
136 |                     fontColor: "#2ed95b",
137 |                     display: true,
138 |                     labelString:"Performance (%)"
139 |                   },
140 |                   ticks:{
141 |                     fontColor: "#d4eaff",
142 |                   }
143 |                 }]
144 |             }
145 |         }
146 |     });
147 |     </script>
148 |     <div class="selection">
149 |       {% from "_formhelpers.html" import render_field %}
150 |       <form action="" method="post">
151 |         <dl>
152 |           {{ render_field(form.ticker) }}
153 |         </dl>
154 |         <button type="submit" name="Plot" class="btn-select"> Plot</button>
155 |         {{ form.csrf_token }}
156 |       </form>
157 |     </div>
158 |   </div>
159 | {% elif group_name is not none and selected_ticker is none%}
160 |   <form class="group-selection" action="{{url_for('charts.chart_breakdown')}}" method="post">
161 |     <span class="selection-label">Select a Watchlist</span>
162 |     <select class="watchlist-selector" name="watchlist_group_selection">
163 |       {% for watchlist_name in user_watchlists %}
164 |       <option value="{{watchlist_name}}">{{watchlist_name}}</option>
165 |       {% endfor %}
166 |     </select>
167 |     <button type="submit" name="btn_btn_default" class="btn-select">Get overview</button>
168 |   </form>
169 | {% else %}
170 | {% endif %}
171 | {% endblock %}
172 | 


--------------------------------------------------------------------------------
/Prescient/templates/securities/dashboard.html:
--------------------------------------------------------------------------------
  1 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/dashboard-styles.css') }}">
  2 | <script src=https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.9.3/Chart.min.js></script>
  3 | {% extends 'base_layout.html' %}
  4 | {% block header %}
  5 | {% if line_chart and group_name %}
  6 |   <h1 class="main-heading">{% block title %}<span class="watchlist-username-title">{{current_user.username}}'s</span> Portfolio Overview for <span class="watchlist-name-title">{{group_name}}</span>{% endblock %}</h1>
  7 |   <br>
  8 | {% else %}
  9 | {% endif %}
 10 | {% endblock %}
 11 | 
 12 | {% block content %}
 13 | {% if line_chart and group_name is defined %}
 14 |   <form class="group-selection" action="{{url_for('dashboard')}}" method="post">
 15 |     <span class="selection-label">Select a Watchlist</span>
 16 |     <select class="watchlist-selector" name="watchlist_group_selection">
 17 |       {% for watchlist_name in user_watchlists %}
 18 |       <option value="{{watchlist_name}}">{{watchlist_name}}</option>
 19 |       {% endfor %}
 20 |     </select>
 21 |     <button type="submit" name="btn btn-default" class="overview-select">Get overview</button>
 22 |   </form>
 23 | 
 24 |   <div class="main-wrapper">
 25 |     <div class="summary-table">
 26 |       <table>
 27 |         <thead>
 28 |           <tr>
 29 |             <th>Name</th>
 30 |             <th>Quantity</th>
 31 |             <th>Average Price</th>
 32 |           </tr>
 33 |         </thead>
 34 |         <tbody>
 35 |           {% for item in summary %}
 36 |           <tr class="watchlist-rows">
 37 |             {% if item.quantity != 0 %}
 38 |             <td class="c2">{{item.ticker}}</td>
 39 |             <td class="c3">{{item.quantity}}</td>
 40 |             <td class="c3">{{item.average_price}}</td>
 41 |             {% endif %}
 42 |           </tr>
 43 |           {% endfor %}
 44 |         </tbody>
 45 |       </table>
 46 |     </div>
 47 |     <div class="pie-chart-container">
 48 |       <canvas id="mypieChart"></canvas>
 49 |     </div>
 50 |     <script>
 51 |     //Chart.defaults.global.responsive = false;
 52 |     var ctx = document.getElementById('mypieChart');
 53 |     var myChart = new Chart(ctx, {
 54 |         type: 'pie',
 55 |         maintainAspectRatio: false,
 56 |         data: {
 57 |             labels: [{% for item in pie_chart %}
 58 |             "{{item.ticker}}",
 59 |             {% endfor %}],
 60 |             datasets: [{
 61 |                 label: 'Weighting',
 62 |                 data: [{% for item in pie_chart %}
 63 |                 "{{item.market_val_perc}}",
 64 |                 {% endfor %}],
 65 |                 backgroundColor: [
 66 |                     'rgba(106, 90, 205, 0.3)',
 67 |                     'rgba(75, 0, 130, 0.3)',
 68 |                     'rgba(178, 34, 34, 0.3)',
 69 |                     'rgba(255, 69, 0, 0.3)',
 70 |                     'rgba(0, 128, 128, 0.3)',
 71 |                     'rgba(16, 87, 194, 0.2)',
 72 |                     'rgba(54, 54, 54, 0.2)'
 73 |                 ],
 74 |                 borderColor: [
 75 |                     'rgba(140, 126, 222, 1)',
 76 |                     'rgba(178, 145, 201, 1)',
 77 |                     'rgba(176, 113, 113, 1)',
 78 |                     'rgba(207, 148, 126, 1)',
 79 |                     'rgba(101, 184, 184, 1)',
 80 |                     'rgba(130, 163, 219, 1)',
 81 |                     'rgba(124, 124, 124, 1)'
 82 | 
 83 |                 ],
 84 |                 borderWidth: 2
 85 |             }]
 86 |         },
 87 |         options: {
 88 |           responsive: true,
 89 |           legend: {
 90 |             labels: {
 91 |               fontColor: "#d4eaff"
 92 |             },
 93 |             position: "bottom",
 94 |           },
 95 |           title: {
 96 |             display: true,
 97 |             text: "Portfolio Distribution by Position",
 98 |             fontColor: "#d4eaff"
 99 |           },
100 |           layout: {
101 |             padding:{
102 |               left: 0,
103 |               right: 50,
104 |               top: 0,
105 |               bottom: 0
106 |             }
107 |           },
108 |           animation: {
109 |             animateScale: true,
110 |             animateRotate:true
111 |           }
112 |         }
113 |     });
114 |     </script>
115 |     <div class="bar-chart-container">
116 |       <canvas id="mybarChart"></canvas>
117 |     </div>
118 |     <script>
119 |     //Chart.defaults.global.responsive = false;
120 |     var ctx = document.getElementById('mybarChart');
121 |     var myChart = new Chart(ctx, {
122 |         type: 'bar',
123 |         maintainAspectRatio: false,
124 |         data: {
125 |             labels: [{% for item in bar_chart %}
126 |             "{{item.ticker}}",
127 |             {% endfor %}],
128 |             datasets: [{
129 |                 label: 'Market Value',
130 |                 data: [{% for item in bar_chart %}
131 |                 "{{item.market_val}}",
132 |                 {% endfor %}],
133 |                 backgroundColor: [
134 |                     'rgba(213, 0, 249, 0.2)',
135 |                     'rgba(194, 24, 91, 0.2)',
136 |                     'rgba(229, 57, 53, 0.2)',
137 |                     'rgba(192, 202, 51, 0.2)',
138 |                     'rgba(255, 214, 0, 0.2)'
139 |                 ],
140 |                 borderColor: [
141 |                     'rgba(234, 128, 252, 1)',
142 |                     'rgba(236, 64, 122, 1)',
143 |                     'rgba(239, 154, 154, 1)',
144 |                     'rgba(230, 238, 156, 1)',
145 |                     'rgba(255, 234, 0, 1)'
146 |                 ],
147 |                 borderWidth: 2
148 |             }]
149 |         },
150 |         options: {
151 |           responsive: true,
152 |           legend: {
153 |             labels:{
154 |               fontColor: "#d4eaff"
155 |             },
156 |             position: "bottom",
157 |             fontColor: "#d4eaff"
158 |           },
159 |           title: {
160 |             display: true,
161 |             text: "Your Largest Positions by Market Value",
162 |             fontColor: "#d4eaff"
163 |           },
164 |           layout: {
165 |             padding:{
166 |               left: 0,
167 |               right: 0,
168 |               top: 0,
169 |               bottom: 0
170 |             }
171 |           },
172 |           animation: {
173 |             animateScale: true,
174 |             animateRotate:true
175 |           },
176 |           scales: {
177 |               xAxes: [{
178 |                 scaleLabel:{
179 |                   display: true,
180 |                   labelString: "Date",
181 |                   fontColor: "#d4eaff"
182 |                 },
183 |                   ticks: {
184 |                       fontColor: "#d4eaff",
185 |                   }
186 |               }],
187 |               yAxes: [{
188 |                 scaleLabel:{
189 |                   fontColor: "#d4eaff",
190 |                   display: true,
191 |                   labelString:"Market Value"
192 |                 },
193 |                 ticks:{
194 |                   fontColor: "#d4eaff",
195 |                   minTicksLimit:6
196 |                 }
197 |               }]
198 |           },
199 |         }
200 |     });
201 |     </script>
202 |     <div class="worldmap-container" id="worldmap-container">
203 |       <!-- Plotly.js -->
204 |       <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
205 | 
206 |       <script type="text/javascript">
207 |       var graph = {{map | safe}};
208 |       Plotly.plot("worldmap-container", graph.data, graph.layout);
209 |       </script>
210 |     </div>
211 |     <div class="line-chart-container">
212 |       <canvas id="myChart" style=""></canvas>
213 |     </div>
214 |     <script>
215 |     //Chart.defaults.global.responsive = false;
216 |     var ctx = document.getElementById('myChart');
217 |     var myChart = new Chart(ctx, {
218 |         type: 'line',
219 |         tooltipCaretSize: 10,
220 |         maintainAspectRatio: false,
221 |         data: {
222 |             labels: [{% for item in line_chart %}
223 |             "{{item.date}}",
224 |             {% endfor %}],
225 |             datasets: [{
226 |                 label: '%',
227 |                 data: [{% for item in line_chart %}
228 |                 "{{item.pct_change}}",
229 |                 {% endfor %}],
230 |                 backgroundColor: [
231 |                     'rgba(54, 162, 235, 0.2)'
232 |                 ],
233 |                 borderColor: [{% for item in line_chart %}
234 |                     'rgba(54, 162, 235, 1)',
235 |                     {% endfor %}
236 |                 ],
237 |                 borderWidth: 2,
238 |                 pointBorderWidth: 1,
239 |                 pointBorderColor: 'rgba(127, 64, 222, 1)'
240 |             }]
241 |         },
242 |         options: {
243 |           responsive:true,
244 |           tooltips: {
245 |             mode: "index",
246 |             intersect:false,
247 |           },
248 |           hover:{
249 |             mode: "nearest",
250 |             intersect: true,
251 |           },
252 |           legend: {
253 |             display: false,
254 |             labels: {
255 |               fontColor: "#d4eaff"
256 |             }
257 |           },
258 |           title: {
259 |             display: true,
260 |             text: "Overall Portfolio Performance",
261 |             fontColor: "#d4eaff"
262 |           },
263 |           layout: {
264 |             padding:{
265 |               left: 20,
266 |               right: 20,
267 |               top: 0,
268 |               bottom: 0
269 |             }
270 |           },
271 |             scales: {
272 |                 xAxes: [{
273 |                   scaleLabel:{
274 |                     display: true,
275 |                     labelString: "Date",
276 |                     fontColor: "#d4eaff"
277 |                   },
278 |                     ticks: {
279 |                         fontColor: "#d4eaff",
280 |                         autoSkip: true,
281 |                         maxTicksLimit: 6,
282 |                         maxRotation: 15,
283 |                         minRotation:15
284 |                     }
285 |                 }],
286 |                 yAxes: [{
287 |                   display:true,
288 |                   scaleLabel:{
289 |                     fontColor: "#d4eaff",
290 |                     display: true,
291 |                     labelString:"Holding Period Return (%)"
292 |                   },
293 |                   ticks:{
294 |                     fontColor: "#d4eaff",
295 |                   }
296 |                 }]
297 |             }
298 |         }
299 |     });
300 |     </script>
301 |   </div>
302 | {% elif not line_chart and group_name is not none%}
303 |   <div class="Welcome2">
304 |     <h1 class="main-heading2">Hi {{current_user.username}},</h1>
305 |     <p>Your watchlist '{{group_name}}' has no trade history!</p>
306 |     <li class="to-watchlist-link"><a href="{{ url_for('watchlist.main') }}">Why not add some securities?</a></li>
307 |   </div>
308 | {%else%}
309 |   <div class="Welcome2">
310 |     <h1 class="main-heading2">Welcome to Prescient Finance</h1>
311 |     <p>Create portfolios and strategies your way!</p>
312 |     <li class="to-watchlist-link"><a href="{{ url_for('watchlist.main') }}">Get started! Create a watchlist here</a></li>
313 |   </div>
314 | {% endif %}
315 | {% endblock %}
316 | 


--------------------------------------------------------------------------------
/Prescient/templates/test.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en" dir="ltr">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>Test Page</title>
 6 |   </head>
 7 |   <h1>THIS IS A TEST PAGE</h1>
 8 |   <body>
 9 |   </body>
10 | </html>
11 | 


--------------------------------------------------------------------------------
/Prescient/templates/watchlist/main.html:
--------------------------------------------------------------------------------
  1 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/watchlist-styles.css') }}">
  2 | <script src="{{ url_for('static', filename='javascript/bootstrap/jquery-3.4.1.js') }}"></script>
  3 | <script src="{{ url_for('static', filename='javascript/bootstrap/bootstrap.js') }}"></script>
  4 | 
  5 | <link rel="stylesheet" href="{{ url_for('static', filename='styles/bootstrap/bootstrap.css') }}">
  6 | {% extends 'base_layout.html' %}
  7 | {% block header %}
  8 | {% if group_name is not none %}
  9 |   <h1 class="main-heading">{% block title %}Entries for <span class="watchlist-name-title">{{group_name}}</span>{% endblock %}</h1
 10 |   <br>
 11 | {% else %}
 12 |   <div class="Welcome2">
 13 |     <h1 class="main-heading2"> You do not have any active watchlists.</h1>
 14 |     <li class="create-watchlist"><a data-toggle="modal" data-target="#mymodal5">Create a watchlist here</a></li>
 15 |   </div>
 16 | {% endif %}
 17 | {% endblock %}
 18 | 
 19 | {% block content %}
 20 | {% if group_name is not none %}
 21 |   <form class="group-selection" action="{{url_for('watchlist.main')}}" method="post">
 22 |     <span class="selection-label">Select a Watchlist</span>
 23 |     <select class="watchlist-selector" name="watchlist_group_selection">
 24 |       {% for watchlist_name in user_watchlists %}
 25 |       <option value="{{watchlist_name}}">{{watchlist_name}}</option>
 26 |       {% endfor %}
 27 |     </select>
 28 |     <button type="submit" class="btn-new-wl">Get overview</button>
 29 |   </form>
 30 |   <div class="summary-table-container">
 31 |     <table>
 32 |       <thead>
 33 |         <tr>
 34 |           <th>Ticker</th>
 35 |           <th>Quantity</th>
 36 |           <th>Average Price</th>
 37 |         </tr>
 38 |       </thead>
 39 |       <tbody>
 40 |         {% for item in summary %}
 41 |         <tr class="watchlist-rows">
 42 |           {% if item.quantity != 0 %}
 43 |           <td class="c2">{{item.ticker}}</td>
 44 |           <td class="c3">{{item.quantity}}</td>
 45 |           <td class="c3">{{item.average_price}}</td>
 46 |           {% endif %}
 47 |         </tr>
 48 |         {% endfor %}
 49 |       </tbody>
 50 |     </table>
 51 |     </div>
 52 |     <br>
 53 |     {% if current_user %}
 54 |       <button type="button" class="btn-new-wl-item"
 55 |       data-toggle="modal" data-target="#mymodal">Add to Watchlist</button>
 56 |         <div id="mymodal" class="modal fade" role="dialog">
 57 |           <div class="modal-dialog">
 58 |             <div class="modal-content">
 59 |               <div class="modal-header">
 60 |                 <h4 class="modal-title">Add to Watchlist</h4>
 61 |               </div>
 62 |               <div class="modal-body">
 63 |                 {% from "_formhelpers.html" import render_field %}
 64 |                 <form action="{{ url_for('watchlist.create')}}" method="post">
 65 |                   <dl>
 66 |                     {{ render_field(form.watchlist) }}
 67 |                     {{ render_field(form.ticker) }}
 68 |                     {{ render_field(form.quantity) }}
 69 |                     {{ render_field(form.price) }}
 70 |                     {{ render_field(form.trade_date) }}
 71 |                     {{ render_field(form.sector) }}
 72 |                     {{ render_field(form.comments) }}
 73 |                   </dl>
 74 |                   <p>{{ form.submit() }}</p>
 75 |                   {{ form.csrf_token }}
 76 |                 </form>
 77 |               </div>
 78 |             </div>
 79 |           </div>
 80 |         </div>
 81 |         <button type="button" class="btn-new-wl"
 82 |         data-toggle="modal" data-target="#mymodal3">Create Watchlist Group</button>
 83 |           <div id="mymodal3" class="modal fade" role="dialog">
 84 |             <div class="modal-dialog">
 85 |               <div class="modal-content">
 86 |                 <div class="modal-header">
 87 |                   <h4 class="modal-title">Create Watchlist</h4>
 88 |                 </div>
 89 |                 <div class="modal-body">
 90 |                   {% from "_formhelpers.html" import render_field %}
 91 |                   <form action="{{ url_for('watchlist.create_group')}}" method="post">
 92 |                     <dl>
 93 |                       {{ render_field(group_form.name) }}
 94 |                     </dl>
 95 |                     <p>{{ group_form.submit() }}</p>
 96 |                     {{ group_form.csrf_token }}
 97 |                   </form>
 98 |                 </div>
 99 |               </div>
100 |             </div>
101 |           </div>
102 |           <button type="button" class="btn-new-wl"
103 |           data-toggle="modal" data-target="#mymodal4">Remove Watchlist Group</button>
104 |             <div id="mymodal4" class="modal fade" role="dialog">
105 |               <div class="modal-dialog">
106 |                 <div class="modal-content">
107 |                   <div class="modal-header">
108 |                     <h4 class="modal-title">Remove Watchlist</h4>
109 |                   </div>
110 |                   <div class="modal-body">
111 |                     {% from "_formhelpers.html" import render_field %}
112 |                     <form class="group-removal" action="{{ url_for('watchlist.delete_group') }}" method="post">
113 |                       <span class="selection-label">Select a Watchlist</span>
114 |                       <select class="watchlist-selector" name="watchlist_group_removed">
115 |                         {% for watchlist_name in user_watchlists %}
116 |                         <option value="{{watchlist_name}}">{{watchlist_name}}</option>
117 |                         {% endfor %}
118 |                       </select>
119 |                       <button type="submit" class="btn-new-wl">Remove Watchlist</button>
120 |                     </form>
121 |                   </div>
122 |                 </div>
123 |               </div>
124 |             </div>
125 |             <button type="button" class="btn-new-wl"
126 |             data-toggle="modal" data-target="#mymodal6">View Tradeable Securities</button>
127 |               <div id="mymodal6" class="modal fade" role="dialog">
128 |                 <div class="modal-dialog modal-lg" style="width:70%">
129 |                   <div class="modal-content">
130 |                     <div class="modal-header">
131 |                       <h4 class="modal-title">All Tradeable Securities</h4>
132 |                     </div>
133 |                     <div class="modal-body">
134 |                       <input type="text" class="filter-bar2" id="filter-tradeable-securities" placeholder="Filter...">
135 |                       <div class="all-securities-table-container">
136 |                         <table class="all-tradeable-securities" id="all-tradeable-securities">
137 |                           <thead>
138 |                             <tr>
139 |                               <th>Ticker</th>
140 |                               <th>Name</th>
141 |                               <th>Country</th>
142 |                               <th>ISO Code</th>
143 |                               <th>Benchmark Index</th>
144 |                             </tr>
145 |                           </thead>
146 |                           <tbody>
147 |                             {% for item in tradeable_securities %}
148 |                             <tr class="security-rows">
149 |                               <td>{{item.ticker}}</td>
150 |                               <td>{{item.name}}</td>
151 |                               <td>{{item.country}}</td>
152 |                               <td>{{item.ISO_alpha3_codes}}</td>
153 |                               <td>{{item.benchmark_index}}</td>
154 |                             </tr>
155 |                             {% endfor %}
156 |                           </tbody>
157 |                         </table>
158 |                         <script src="{{ url_for('static', filename='javascript/watchlist-all-security-filter.js') }}"></script>
159 |                         </div>
160 |                     </div>
161 |                   </div>
162 |                 </div>
163 |               </div>
164 |     {% endif %}
165 |       <input type="text" class="filter-bar" id="filter" placeholder="Filter...">
166 |       <table class="all-trades" id="all-trades">
167 |         <thead>
168 |           <tr>
169 |             <th>Order ID</th>
170 |             <th>Ticker</th>
171 |             <th>Quantity</th>
172 |             <th>Price</th>
173 |             <th>Sector</th>
174 |             <th>Trade Date</th>
175 |             <th>comments</th>
176 |             <th>changes?</th>
177 |           </tr>
178 |         </thead>
179 |         <tbody>
180 |           {% for item in watchlist %}
181 |           <tr class="watchlist-rows">
182 |             <td class="c1">{{item.id}}</td>
183 |             <td class="c2">{{item.ticker}}</td>
184 |             <td class="c3">{{item.quantity}}</td>
185 |             <td class="c4">{{item.price}}</td>
186 |             <td class="c5">{{item.sector}}</td>
187 |             <td class="c6">{{item.trade_date.strftime('%d-%m-%Y')}}</td>
188 |             <td>{{item.comments}}</td>
189 |             <td class="edit-trade">
190 |               {% if current_user.id == item.user_id %}
191 |                 <button type="button" class="btn-new-wl"
192 |                 data-toggle="modal" data-target="#mymodal2{{item.id}}">Edit</button>
193 |                   <div id="mymodal2{{item.id}}" class="modal fade" role="dialog">
194 |                     <div class="modal-dialog" id="{{item.id}}">
195 |                       <div class="modal-content">
196 |                         <div class="modal-header">
197 |                           <h4 class="modal-title">Edit</h4>
198 |                         </div>
199 |                         <div class="modal-body">
200 |                           {% from "_formhelpers.html" import render_field %}
201 |                           <form action="{{ url_for('watchlist.update', id=item.id, ticker=item.ticker) }}" method="post">
202 |                             <dl>
203 |                               {{ render_field(form.watchlist) }}
204 |                               {{ render_field(form.ticker, value=item.ticker, readonly="readonly") }}
205 |                               {{ render_field(form.quantity, value=item.quantity) }}
206 |                               {{ render_field(form.price, value=item.price) }}
207 |                               {{ render_field(form.trade_date, value=item.trade_date.strftime('%Y-%m-%d %H:%M:%S')) }}
208 |                               {{ render_field(form.sector, value=item.sector) }}
209 |                               {{ render_field(form.comments, default=item.comments) }}
210 |                             </dl>
211 |                             {{ form.csrf_token }}
212 |                             <button type="submit" name="button" class="btn btn-primary">Save Changes</button>
213 |                           </form>
214 |                         </div>
215 |                       </div>
216 |                     </div>
217 |                   </div>
218 |                 <form action="{{ url_for('watchlist.delete', id=item.id) }}" method="post">
219 |                   <input class="danger" type="submit" value="Delete" onclick="return confirm('Are you sure you want to delete Order ID {{item.id}}?');">
220 |                 </form>
221 |               {% endif %}
222 |             </td>
223 |           </tr>
224 |           {% endfor %}
225 |         </tbody>
226 |       </table>
227 |       <script src="{{ url_for('static', filename='javascript/watchlist-filter.js') }}"></script>
228 |   {% else %}
229 |       <div id="mymodal5" class="modal fade" role="dialog">
230 |         <div class="modal-dialog">
231 |           <div class="modal-content">
232 |             <div class="modal-header">
233 |               <h4 class="modal-title">Create Watchlist</h4>
234 |             </div>
235 |             <div class="modal-body">
236 |               {% from "_formhelpers.html" import render_field %}
237 |               <form action="{{ url_for('watchlist.create_group')}}" method="post">
238 |                 <dl>
239 |                   {{ render_field(group_form.name) }}
240 |                 </dl>
241 |                 <p>{{ group_form.submit() }}</p>
242 |                 {{ group_form.csrf_token }}
243 |               </form>
244 |             </div>
245 |           </div>
246 |         </div>
247 |       </div>
248 | {% endif %}
249 | {% endblock %}
250 | 


--------------------------------------------------------------------------------
/Prescient/test.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/Prescient/test.db


--------------------------------------------------------------------------------
/Prescient/views/__init__.py:
--------------------------------------------------------------------------------
1 | import Prescient.views.auth
2 | import Prescient.views.dashboard
3 | import Prescient.views.watchlist
4 | import Prescient.views.charts
5 | 


--------------------------------------------------------------------------------
/Prescient/views/auth.py:
--------------------------------------------------------------------------------
 1 | from Prescient import db
 2 | from flask import (Blueprint, flash,
 3 |                    redirect, render_template,
 4 |                    url_for, session)
 5 | from Prescient.models import User
 6 | from flask_login import current_user, login_user, logout_user
 7 | from werkzeug.security import check_password_hash, generate_password_hash
 8 | from Prescient.forms import RegistrationForm, LoginForm
 9 | 
10 | 
11 | bp = Blueprint("auth", __name__, url_prefix="/auth")
12 | 
13 | 
14 | @bp.route('/test')
15 | def test():
16 |     return render_template("test.html")
17 | 
18 | 
19 | @bp.route("/register", methods=("GET", "POST"))
20 | def register():
21 |     if current_user.is_authenticated:
22 |         return redirect(url_for("dashboard"))
23 | 
24 |     form = RegistrationForm()
25 |     if form.validate_on_submit():
26 |         username = form.username.data
27 |         password = generate_password_hash(form.password.data)
28 |         new_user = User(username=username, password=password)
29 |         db.session.add(new_user)
30 |         db.session.commit()
31 |         flash("Your account has now been created!")
32 |         return redirect(url_for("auth.login"))
33 | 
34 |     return render_template("auth/register.html", title="Register", form=form)
35 | 
36 | 
37 | @bp.route("/login", methods=("GET", "POST"))
38 | def login():
39 |     if current_user.is_authenticated:
40 |         return redirect(url_for("dashboard.index"))
41 | 
42 |     form = LoginForm()
43 |     if form.validate_on_submit():
44 |         user = User.query.filter_by(username=form.username.data).first()
45 |         if user is None:
46 |             flash("Invalid username or password")
47 |             return redirect(url_for("auth.login"))
48 |         check = check_password_hash(user.password, form.password.data)
49 |         if not check:
50 |             flash("Invalid username or password")
51 |             return redirect(url_for("auth.login"))
52 |         login_user(user, remember=form.remember_me.data)
53 |         session["ATEST"] = None
54 |         return redirect(url_for("dashboard.index"))
55 |     return render_template("auth/login.html", title="Log In", form=form)
56 | 
57 | 
58 | @bp.route('/logout')
59 | def logout():
60 |     try:
61 |         if session["ATEST"]:
62 |             session.pop('ATEST', None)
63 |     except KeyError:
64 |         pass
65 |     logout_user()
66 |     return redirect(url_for('auth.login'))
67 | 


--------------------------------------------------------------------------------
/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/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/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('/<int:id>/<ticker>/update', methods=('GET', 'POST'))
219 | @login_required
220 | def update(id, ticker):
221 |     user_id = current_user.id
222 |     check = check_watchlist_id(id)
223 |     form = WatchlistItemsForm()
224 |     form.order_id.data = id
225 |     group_form = WatchlistGroupForm()
226 |     form.sector.choices = get_sectors()
227 |     form.watchlist.choices = get_watchlist_choices(user_id)
228 |     if form.validate_on_submit() and check:
229 |         new_watchlist = form.watchlist.data
230 |         new_group_id = get_group_id(new_watchlist, user_id)
231 |         item = WatchlistItems.query.filter_by(id=id, user_id=user_id).first()
232 |         item.ticker = ticker
233 |         item.watchlist = new_watchlist
234 |         item.quantity = form.quantity.data
235 |         item.price = form.price.data
236 |         item.trade_date = form.trade_date.data
237 |         item.sector = form.sector.data
238 |         item.comments = form.comments.data
239 |         item.group_id = new_group_id
240 |         db.session.commit()
241 |         flash(f"Order ID {id} has now been updated")
242 |         return redirect(url_for("watchlist.main"))
243 |     elif form.errors:
244 |         for error_name, error_desc in form.errors.items():
245 |             error_name = error_name.title()
246 |             flash(f"{error_name}: {error_desc[0]}")
247 |             return redirect(url_for("watchlist.main"))
248 |     return render_template("watchlist/main.html", form=form, group_form=group_form)
249 | 
250 | 
251 | @bp.route('/<int:id>/delete', methods=('POST',))
252 | @login_required
253 | def delete(id):
254 |     check = check_watchlist_id(id)
255 |     user_id = current_user.id
256 |     if check:
257 |         item = WatchlistItems.query.filter_by(id=id, user_id=user_id).first()
258 |         db.session.delete(item)
259 |         db.session.commit()
260 |         return redirect(url_for('watchlist.main'))
261 |     return redirect(url_for('watchlist.main'))
262 | 
263 | 
264 | @bp.route('/delete-group', methods=('POST',))
265 | @login_required
266 | def delete_group():
267 |     if request.method == "POST":
268 |         name = request.form.get('watchlist_group_removed')
269 |         user_id = current_user.id
270 |         group_id = get_group_id(name, user_id)
271 |         item = Watchlist_Group.query.filter_by(id=group_id, name=name, user_id=user_id).first()
272 |         WatchlistItems.query.filter_by(group_id=group_id, user_id=user_id).delete(synchronize_session="fetch")  # temp solution until cascading works
273 |         db.session.delete(item)
274 |         db.session.commit()
275 |         return redirect(url_for('watchlist.main'))
276 |     return redirect(url_for('watchlist.main'))
277 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Forks][forks-shield]][forks-url]
 2 | [![Stargazers][stars-shield]][stars-url]
 3 | [![Issues][issues-shield]][issues-url]
 4 | [![MIT License][license-shield]][license-url]
 5 | 
 6 | # Data App Project (Prescient Finance)
 7 | A Web Application that allows users to create dummy portfolios or watchlists to monitor or test their trading strategies. Written in Python using the Flask web framework.
 8 | * Front-End: HTML, CSS, JS, ChartJS, Plotly
 9 | * Back-End: Flask(Python), SQL-Alchemy, MySQL
10 | * Other Libraries: Pandas
11 | <img src="screenshots/Dashboard.PNG" width="500">
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 | [<img src="https://img.youtube.com/vi/CpiltoZI94M/maxresdefault.jpg" width="75%">](https://www.youtube.com/watch?v=CpiltoZI94M)
43 | 
44 | 
45 | 
46 | # Screenshots
47 | <img src="screenshots/performance-charts.PNG" width="500">
48 | <img src="screenshots/watchlist.PNG" width="500">
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 | 


--------------------------------------------------------------------------------
/migrations/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration.


--------------------------------------------------------------------------------
/migrations/__pycache__/env.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/migrations/__pycache__/env.cpython-37.pyc


--------------------------------------------------------------------------------
/migrations/alembic.ini:
--------------------------------------------------------------------------------
 1 | # A generic, single database configuration.
 2 | 
 3 | [alembic]
 4 | # template used to generate migration files
 5 | # file_template = %%(rev)s_%%(slug)s
 6 | 
 7 | # set to 'true' to run the environment during
 8 | # the 'revision' command, regardless of autogenerate
 9 | # revision_environment = false
10 | 
11 | 
12 | # Logging configuration
13 | [loggers]
14 | keys = root,sqlalchemy,alembic
15 | 
16 | [handlers]
17 | keys = console
18 | 
19 | [formatters]
20 | keys = generic
21 | 
22 | [logger_root]
23 | level = WARN
24 | handlers = console
25 | qualname =
26 | 
27 | [logger_sqlalchemy]
28 | level = WARN
29 | handlers =
30 | qualname = sqlalchemy.engine
31 | 
32 | [logger_alembic]
33 | level = INFO
34 | handlers =
35 | qualname = alembic
36 | 
37 | [handler_console]
38 | class = StreamHandler
39 | args = (sys.stderr,)
40 | level = NOTSET
41 | formatter = generic
42 | 
43 | [formatter_generic]
44 | format = %(levelname)-5.5s [%(name)s] %(message)s
45 | datefmt = %H:%M:%S
46 | 


--------------------------------------------------------------------------------
/migrations/env.py:
--------------------------------------------------------------------------------
 1 | from __future__ import with_statement
 2 | 
 3 | import logging
 4 | from logging.config import fileConfig
 5 | 
 6 | from sqlalchemy import engine_from_config
 7 | from sqlalchemy import pool
 8 | 
 9 | from alembic import context
10 | 
11 | # this is the Alembic Config object, which provides
12 | # access to the values within the .ini file in use.
13 | config = context.config
14 | 
15 | # Interpret the config file for Python logging.
16 | # This line sets up loggers basically.
17 | fileConfig(config.config_file_name)
18 | logger = logging.getLogger('alembic.env')
19 | 
20 | # add your model's MetaData object here
21 | # for 'autogenerate' support
22 | # from myapp import mymodel
23 | # target_metadata = mymodel.Base.metadata
24 | from flask import current_app
25 | config.set_main_option(
26 |     'sqlalchemy.url', current_app.config.get(
27 |         'SQLALCHEMY_DATABASE_URI').replace('%', '%%'))
28 | target_metadata = current_app.extensions['migrate'].db.metadata
29 | 
30 | # other values from the config, defined by the needs of env.py,
31 | # can be acquired:
32 | # my_important_option = config.get_main_option("my_important_option")
33 | # ... etc.
34 | 
35 | 
36 | def run_migrations_offline():
37 |     """Run migrations in 'offline' mode.
38 | 
39 |     This configures the context with just a URL
40 |     and not an Engine, though an Engine is acceptable
41 |     here as well.  By skipping the Engine creation
42 |     we don't even need a DBAPI to be available.
43 | 
44 |     Calls to context.execute() here emit the given string to the
45 |     script output.
46 | 
47 |     """
48 |     url = config.get_main_option("sqlalchemy.url")
49 |     context.configure(
50 |         url=url, target_metadata=target_metadata, literal_binds=True
51 |     )
52 | 
53 |     with context.begin_transaction():
54 |         context.run_migrations()
55 | 
56 | 
57 | def run_migrations_online():
58 |     """Run migrations in 'online' mode.
59 | 
60 |     In this scenario we need to create an Engine
61 |     and associate a connection with the context.
62 | 
63 |     """
64 | 
65 |     # this callback is used to prevent an auto-migration from being generated
66 |     # when there are no changes to the schema
67 |     # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
68 |     def process_revision_directives(context, revision, directives):
69 |         if getattr(config.cmd_opts, 'autogenerate', False):
70 |             script = directives[0]
71 |             if script.upgrade_ops.is_empty():
72 |                 directives[:] = []
73 |                 logger.info('No changes in schema detected.')
74 | 
75 |     connectable = engine_from_config(
76 |         config.get_section(config.config_ini_section),
77 |         prefix='sqlalchemy.',
78 |         poolclass=pool.NullPool,
79 |     )
80 | 
81 |     with connectable.connect() as connection:
82 |         context.configure(
83 |             connection=connection,
84 |             target_metadata=target_metadata,
85 |             process_revision_directives=process_revision_directives,
86 |             **current_app.extensions['migrate'].configure_args
87 |         )
88 | 
89 |         with context.begin_transaction():
90 |             context.run_migrations()
91 | 
92 | 
93 | if context.is_offline_mode():
94 |     run_migrations_offline()
95 | else:
96 |     run_migrations_online()
97 | 


--------------------------------------------------------------------------------
/migrations/script.py.mako:
--------------------------------------------------------------------------------
 1 | """${message}
 2 | 
 3 | Revision ID: ${up_revision}
 4 | Revises: ${down_revision | comma,n}
 5 | Create Date: ${create_date}
 6 | 
 7 | """
 8 | from alembic import op
 9 | import sqlalchemy as sa
10 | ${imports if imports else ""}
11 | 
12 | # revision identifiers, used by Alembic.
13 | revision = ${repr(up_revision)}
14 | down_revision = ${repr(down_revision)}
15 | branch_labels = ${repr(branch_labels)}
16 | depends_on = ${repr(depends_on)}
17 | 
18 | 
19 | def upgrade():
20 |     ${upgrades if upgrades else "pass"}
21 | 
22 | 
23 | def downgrade():
24 |     ${downgrades if downgrades else "pass"}
25 | 


--------------------------------------------------------------------------------
/migrations/versions/__pycache__/ac98739c7dd8_.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/migrations/versions/__pycache__/ac98739c7dd8_.cpython-37.pyc


--------------------------------------------------------------------------------
/migrations/versions/ac98739c7dd8_.py:
--------------------------------------------------------------------------------
 1 | """empty message
 2 | 
 3 | Revision ID: ac98739c7dd8
 4 | Revises: 
 5 | Create Date: 2020-03-14 12:15:48.926767
 6 | 
 7 | """
 8 | from alembic import op
 9 | import sqlalchemy as sa
10 | 
11 | 
12 | # revision identifiers, used by Alembic.
13 | revision = 'ac98739c7dd8'
14 | down_revision = None
15 | branch_labels = None
16 | depends_on = None
17 | 
18 | 
19 | def upgrade():
20 |     # ### commands auto generated by Alembic - please adjust! ###
21 |     op.create_table('available_securities',
22 |     sa.Column('name', sa.String(length=70), nullable=True),
23 |     sa.Column('ticker', sa.String(length=20), nullable=False),
24 |     sa.Column('country', sa.String(length=40), nullable=True),
25 |     sa.Column('benchmark_index', sa.String(length=30), nullable=True),
26 |     sa.Column('ISO_alpha3_codes', sa.String(length=3), nullable=True),
27 |     sa.PrimaryKeyConstraint('ticker')
28 |     )
29 |     op.create_table('login_details',
30 |     sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
31 |     sa.Column('username', sa.String(length=25), nullable=False),
32 |     sa.Column('password', sa.String(length=257), nullable=False),
33 |     sa.PrimaryKeyConstraint('id')
34 |     )
35 |     op.create_index(op.f('ix_login_details_username'), 'login_details', ['username'], unique=True)
36 |     op.create_table('sector_definitions',
37 |     sa.Column('name', sa.String(length=70), nullable=False),
38 |     sa.PrimaryKeyConstraint('name')
39 |     )
40 |     op.create_index(op.f('ix_sector_definitions_name'), 'sector_definitions', ['name'], unique=False)
41 |     op.create_table('watchlist_group',
42 |     sa.Column('id', sa.Integer(), nullable=False),
43 |     sa.Column('name', sa.String(length=25), nullable=False),
44 |     sa.Column('user_id', sa.Integer(), nullable=False),
45 |     sa.ForeignKeyConstraint(['user_id'], ['login_details.id'], ),
46 |     sa.PrimaryKeyConstraint('id')
47 |     )
48 |     op.create_table('watchlist_securities',
49 |     sa.Column('id', sa.Integer(), nullable=False),
50 |     sa.Column('watchlist', sa.String(length=25), nullable=False),
51 |     sa.Column('ticker', sa.String(length=20), nullable=False),
52 |     sa.Column('quantity', sa.Integer(), nullable=False),
53 |     sa.Column('price', sa.Float(), nullable=False),
54 |     sa.Column('sector', sa.String(length=100), nullable=False),
55 |     sa.Column('trade_date', sa.DateTime(), nullable=True),
56 |     sa.Column('created_timestamp', sa.DateTime(), nullable=True),
57 |     sa.Column('comments', sa.String(length=140), nullable=True),
58 |     sa.Column('user_id', sa.Integer(), nullable=False),
59 |     sa.Column('group_id', sa.Integer(), nullable=False),
60 |     sa.ForeignKeyConstraint(['group_id'], ['watchlist_group.id'], ),
61 |     sa.ForeignKeyConstraint(['user_id'], ['login_details.id'], ),
62 |     sa.PrimaryKeyConstraint('id')
63 |     )
64 |     op.create_index(op.f('ix_watchlist_securities_id'), 'watchlist_securities', ['id'], unique=False)
65 |     # ### end Alembic commands ###
66 | 
67 | 
68 | def downgrade():
69 |     # ### commands auto generated by Alembic - please adjust! ###
70 |     op.drop_index(op.f('ix_watchlist_securities_id'), table_name='watchlist_securities')
71 |     op.drop_table('watchlist_securities')
72 |     op.drop_table('watchlist_group')
73 |     op.drop_index(op.f('ix_sector_definitions_name'), table_name='sector_definitions')
74 |     op.drop_table('sector_definitions')
75 |     op.drop_index(op.f('ix_login_details_username'), table_name='login_details')
76 |     op.drop_table('login_details')
77 |     op.drop_table('available_securities')
78 |     # ### end Alembic commands ###
79 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | alpha-vantage
 2 | mysql-connector==2.2.9
 3 | mysql-connector-python==8.0.19
 4 | mysqlclient==1.4.6
 5 | numpy
 6 | pandas
 7 | Flask==1.1.1
 8 | requests
 9 | plotly
10 | WTForms==2.2.1
11 | Flask-Login==0.5.0
12 | Flask-Migrate==2.5.2
13 | Flask-Script==2.0.6
14 | Flask-SQLAlchemy==2.4.1
15 | Flask-WTF==0.14.3
16 | 


--------------------------------------------------------------------------------
/screenshots/Dashboard.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/screenshots/Dashboard.PNG


--------------------------------------------------------------------------------
/screenshots/performance-charts.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/screenshots/performance-charts.PNG


--------------------------------------------------------------------------------
/screenshots/watchlist.PNG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RamonWill/Data-App/e4b28704940546156f9521c88eced73f1443ce7e/screenshots/watchlist.PNG


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/tests/test_watchlists.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 | # Integeration Tests
13 | class WatchlistTests(unittest.TestCase):
14 |     def setUp(self):
15 |         app.config["TESTING"] = True
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()
21 |         db.create_all()
22 | 
23 |     def tearDown(self):
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 add_group(self, group_name):
44 |         new_group = dict(name=group_name, user_id=999)
45 |         return self.app.post("/create-group", data=new_group,
46 |                              follow_redirects=True)
47 | 
48 |     def test_watchlist_urls(self):
49 |         response_main_page = self.app.get("/main", follow_redirects=True)
50 |         response_create_security = self.app.get("/create", follow_redirects=True)
51 |         response_create_group = self.app.get("/create-group", follow_redirects=True)
52 |         response_update = self.app.get("1/DIS/update", follow_redirects=True)
53 | 
54 |         self.assertEqual(response_main_page.status_code, 200)
55 |         self.assertEqual(response_create_security.status_code, 200)
56 |         self.assertEqual(response_create_group.status_code, 200)
57 |         self.assertEqual(response_update.status_code, 200)
58 | 
59 |     def test_valid_group_creation(self):
60 |         self.register_user("test_user1", "admin123", "admin123")
61 |         self.login_user("test_user1", "admin123")
62 |         response = self.add_group("RANDOM PORTFOLIO")
63 |         self.assertIn(b"RANDOM PORTFOLIO", response.data)
64 | 
65 |     def test_invalid_group_creation(self):
66 |         self.register_user("test_user1", "admin123", "admin123")
67 |         self.login_user("test_user1", "admin123")
68 |         response = self.add_group("")
69 |         self.assertIn(b"Name: This field is required.", response.data)
70 | 
71 | 
72 | if __name__ == "__main__":
73 |     unittest.main()
74 | 


--------------------------------------------------------------------------------
/wsgi.py:
--------------------------------------------------------------------------------
 1 | from Prescient import app, db
 2 | from Prescient import models
 3 | 
 4 | 
 5 | @app.shell_context_processor
 6 | def make_shell_context():
 7 |     return {"db": db,
 8 |             "User": models.User,
 9 |             "Watchlist": models.WatchlistItems,
10 |             "Groups": models.Watchlist_Group,
11 |             "sectors": models.Sector_Definitions}
12 | 


--------------------------------------------------------------------------------