def testPageLinkWithParameters(self):
result = PageLink("hello", Page(""), {
"team": "aasa",
"league": "afafa"
}).url
self.assertEqual("/cgi-bin/page.py?id=hello&league=afafa&team=aasa",
result)
def click(self):
name = self.name
self._root_element.find_element(*self._name_locator).click()
current_subpage = self._item_page[name](self.testsetup).current_subpage
if current_subpage is None:
current_subpage = Page(self.testsetup)
return current_subpage
def test_hexagon(self, setup):
hexagon = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.hexagon(hexagon[9][1])
results = page.get_page_results()
expected_results = pages.results.get_hexagon_results(hexagon[9][0])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_square(self, setup):
square = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.square(square[3][1])
results = page.get_page_results()
expected_results = pages.results.get_square_results(square[3][0])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_trapeze(self, setup):
trapeze = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.trapeze(trapeze[7][1], trapeze[7][3], trapeze[7][5])
result = page.get_page_result()
expected_result = pages.results.get_trapeze_results(
trapeze[7][0], trapeze[7][2], trapeze[7][4])
assert result[0] == expected_result[0], message[0]
def test_polygon(self, setup):
polygon = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.polygon(polygon[10][1], polygon[10][3])
results = page.get_page_results()
expected_results = pages.results.get_polygon_results(
polygon[10][0], polygon[10][2])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def testPageLinkWithParametersAndPreExistingSession(self):
page = Page("")
page.allParams = {"session": "aaaaa"}
result = PageLink("hello", page, {
"team": "aasa",
"league": "afafa"
}).url
self.assertEqual(
"/cgi-bin/page.py?id=hello&session=aaaaa&league=afafa&team=aasa",
result)
def test_pythagorean_theorem(self, setup):
pythagorean_theorem = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.pythagorean_theorem(pythagorean_theorem[11][1],
pythagorean_theorem[11][3])
result = page.get_page_pythagorean_theorem_result()
expected_result = pages.results.get_pythagorean_theorem_result(
pythagorean_theorem[11][0], pythagorean_theorem[11][2])
assert result == expected_result, message[0]
def test_circle(self, setup):
circle = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.circle(circle[0][1], circle[0][3])
results = page.get_page_results()
expected_results = pages.results.get_circle_results(
circle[0][0], circle[0][2])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_rectangle(self, setup):
rectangle = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.rectangle(rectangle[4][1], rectangle[4][3])
results = page.get_page_results()
expected_results = pages.results.get_rectangle_results(
rectangle[4][0], rectangle[4][2])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_rhombus(self, setup):
rhombus = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.rhombus(rhombus[5][1], rhombus[5][3])
results = page.get_page_results()
expected_results = pages.results.get_rhombus_results(
rhombus[5][0], rhombus[5][2])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_parallelogram(self, setup):
parallelogram = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.parallelogram(parallelogram[6][1], parallelogram[6][3],
parallelogram[6][5])
results = page.get_page_results()
expected_results = pages.results.get_parallelogram_results(
parallelogram[6][0], parallelogram[6][2], parallelogram[6][4])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
def test_triangle(self, setup):
triangle = Data.get_data()
message = Data.setup_data()
page = Page(self.driver)
page.triangle(triangle[1][1], triangle[1][3], triangle[1][5],
triangle[1][7])
results = page.get_page_results()
expected_results = pages.results.get_triangle_results(
triangle[1][0], triangle[1][2], triangle[1][4], triangle[1][6])
assert results[0] == expected_results[0], message[0]
assert results[1] == expected_results[1], message[0]
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
import plotly.express as px
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from model.diversification_data_processor import DiversificationDataProcessor
from pages.page import Page
sample_data = px.data.stocks()
sample_data = pd.DataFrame(sample_data)
page = Page("Diversification")
page.set_path('/analysis/diversification')
metrics = ['asset-list', 'number-of-shares']
page.set_storage(metrics)
page.set_layout([
html.H1(
page.name,
style={
"margin-bottom": "10px",
"margin-left": "4px",
},
),
html.Br(),
dcc.Graph(id='sunburst'),
dcc.Graph(id='industry-pie-chart'),
dcc.Graph(id='sector-pie-chart'),
def setUp(cls):
browser = BrowserEngine(cls)
cls.driver = browser.open_browser(cls)
cls.driver.implicitly_wait(20)
cls.page = Page(cls.driver)
def getPage(self, pageId, params={}):
answer = Page(pageId)
answer.allParams = params
return answer
def try_pyppeteer():
data_store.spec['page_async'] = Page()
asyncio.run(data_store.spec['page_async'].page_async())
def setUp(self):
browser = BrowserEngine(self)
self.driver = browser.open_browser(self)
self.page = Page(self.driver)
from datetime import datetime, timedelta
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
import yfinance as yf
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from pages.analysis.asset_mode_dropdown import generate_analysis_mode_dropdown
from pages.page import Page
page = Page("Exit-Quality")
page.set_path('/pages/exit_quality')
page.set_storage(['asset-list', 'buy-price-dict', 'sell-price-dict'])
exit_quality_gauge = {
'axis': {
'range': [-100, 100]
},
'bar': {
'color': 'black'
},
'steps': [{
'range': [-100, 0],
'color': 'red'
}, {
'range': [0, 50],
'color': 'orange'
}, {
import io
import dash
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
import dash_table
import pandas as pd
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from pages.page import Page
from pages.trade_data_formatting import individual_trades_columns
page = Page('Trade-Journal')
page.set_path('/')
trades_table = dash_table.DataTable(
id='trades-table',
columns=individual_trades_columns,
editable=True,
row_deletable=True,
style_cell={
'padding': '5px',
'border': '1px solid black',
'textAlign': 'center',
'font_family': 'Arial',
'font_size': '12px',
'backgroundColor': 'ghostwhite'
}, # Style the cells
def setUp(self):
browser = BrowserEngine(self)
self.driver = browser.open_browser(self)
self.driver.implicitly_wait(20)
self.page = Page(self.driver)
new_book = datetime.strftime(self.record_time - new_book_delta,
"%Y-%m-%dT%H:%M")
except:
print >> sys.stderr, "Error:new_book\n", hotel
new_book = None
new_book_delta = None
try:
self.dt_hotels[hotel["id"]] = {
"title": title,
"low_price": low_price,
"judge_score": judge_score,
"judge_users": judge_users,
"new_book": new_book,
"new_book_delta": new_book_delta,
"star": labels["star"]
}
# self.dt_hotels[hotel["id"]].update(labels)
except Exception as e:
print >> sys.stderr, e
continue
return self.dt_hotels
if __name__ == "__main__":
with open("1", "r") as fp:
docs = ''.join(fp.readlines())
page = Page(docs)
page.extract()
def page(self, page_name, menu_name="menu"):
self.__page = Page(page_name)
if self.__menu == None:
self.__menu = MenuPage(menu_name)
return self.__page
def setUp(cls):
browser = BrowserEngine(cls)
cls.driver = browser.open_browser(cls)
cls.page = Page(cls.driver)
from datetime import datetime, timedelta
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
import yfinance as yf
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from pages.analysis.asset_mode_dropdown import generate_analysis_mode_dropdown
from pages.page import Page
page = Page('Benchmark-Comparison')
page.set_path('/analysis/benchmark-comparison')
page.set_storage(['asset-list'])
page.set_layout([
html.H1(
page.name,
style={
"margin-bottom": "10px",
"margin-left": "4px",
},
),
html.Div(children='''
Choose an asset to benchmark
'''),
html.Br(),
generate_analysis_mode_dropdown(page.id),
def init_browser():
data_store.spec['browser'] = Page().browser()
data_store.spec['browser'].visit('http://www.baidu.com')
def testPageLinkNoParameters(self):
result = PageLink("hello", Page(""), {}).url
self.assertEqual("/cgi-bin/page.py?id=hello", result)
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from helper_functions.date_utils import remove_day_time
from helper_functions.get_t_bill_return import get_t_bill_return
from helper_functions.ratio_metrics import *
from helper_functions.return_metrics import calculate_rate_of_return, calculate_gain_to_pain
from pages.page import Page
page = Page("Reward-Risk")
page.set_path('/pages/reward_risk')
page.set_storage([
'asset-list', 'aggregate-value-by-day', 'portfolio-gains',
'portfolio-losses'
])
default_gauge = {
'axis': {
'range': [-1, 4]
},
'bar': {
'color': 'black'
},
'steps': [{
'range': [-1, 1],
'color': 'red'
}, {
import requests
from pages.page import Page
page_content = requests.get("--HERE IS YOUR LINK--").content
page = Page(page_content)
import csv
with open("Hyperlinks-on-page.csv", "w") as f:
f.write('Text,target,Need to be fixed,href\n')
for link in page.FAQ:
f.write(link.csvline)
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
import plotly.express as px
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
from app import app
from pages.page import Page
page = Page('Overview')
page.set_path('/analysis/overview')
asset_list = ['ALL ASSETS', 'GOOG', 'AMZN']
overview_metrics = [
'profit-list', 'rate-of-return', 'aggregate-value-by-day',
'total-amount-traded'
]
page.set_storage(overview_metrics)
metrics = html.Div([
dbc.Row([
dbc.Col(
html.Div(
[html.H3(id="p&l"), html.P("P&L")],
id="p&l",
className="mini_container",
)),
], ),
dbc.Row([
