def display_page(pathname):
if pathname == '/':
return main.layout
elif pathname == '/test':
return dummy.layout
else:
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognized..."),
])
def render_page_content(pathname):
if pathname == "/":
return page_content_face
elif pathname == "/face-verification":
return page_content_face
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == home_page_location:
return home.layout
elif pathname == home1_page_location:
return home1.layout
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == url_base_pathname:
return home_layout
elif pathname == url_base_pathname + "voters":
return voters_layout
elif pathname != "/":
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ['/', '/uk']:
return layout_uk
elif pathname == '/world':
return layout_world
elif pathname == '/map':
return layout_map
return dbc.Jumbotron([
html.H1('404: Not found', className='text-danger'),
html.Hr(),
html.P(f'The pathname {pathname} was not recognised...')
])
def display_page(pathname):
if pathname in ['/', '/dashboard']:
return [NAVBAR, BODY]
elif pathname == '/download':
return [NAVBAR, DOWNLOAD]
return dbc.Jumbotron(
[
html.H1('404: Not found', className='text-danger'),
html.Hr(),
html.P(f'The pathname {pathname} is invalid'),
]
)
def render_page_content(pathname):
if pathname in ["/", "/home"]:
return home.layout
elif pathname == "/apps/technical":
return technical.layout
elif pathname == "/apps/resources":
return resources.layout
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def get_page_desc(id):
return [
dbc.Row([
dbc.Col([
dbc.Jumbotron(id=id,
style={
'paddingBottom': '0.5rem',
'paddingTop': '0.8rem'
})
]),
], )
]
def get_header():
return dbc.Jumbotron([
html.H1("Carbon Footprint", style={"textAlign": "center"}),
html.P(
"Measure Compute Emissions",
style={
"textAlign": "center",
"paddingLeft": "0.5%"
},
className="lead",
),
])
def get_model_desc(id):
"""This is the big text card that has the technical details of the model"""
return [
dbc.Row(
justify="center",
children=dbc.Jumbotron(id=id,
style={
'paddingBottom': '0.5rem',
'paddingTop': '0.8rem'
}),
),
]
def by_flavfeels(general_dropdown, flavor_dropdown, medical_dropdown):
body2 = html.Div([
dbc.Row([
dbc.Col([
dbc.Jumbotron([
html.Div([
html.H4("Search By Flavors & Feelings"),
html.Br(),
html.H6("What feelings do you like?"),
dcc.Dropdown(
id="feelings_drop",
options=general_dropdown.to_dict(orient='records'),
value=None,
placeholder="Select Feelings",
multi=True),
html.Br(),
html.H6("What flavors do you like?"),
dcc.Dropdown(
id="flavors_drop",
options=flavor_dropdown.to_dict(orient='records'),
value=None,
placeholder="Select Flavors",
multi=True),
html.Br(),
html.H6(
"What medical conditions do you want to treat?"),
dcc.Dropdown(
id="medical_drop",
options=medical_dropdown.to_dict(orient='records'),
value=None,
placeholder="Select Medical Condition to Treat",
multi=True),
html.Br(),
dbc.Button(
"CannaRec Me!", id="letsgo2", color="primary")
],
className="question-section")
],
className="logon container margin-up")
],
width={
'size': 4,
'offset': 1
}),
dbc.Col([
dcc.Loading([html.Div([], id="results2", className="results")])
],
width={'size': 6},
className="margin-up")
], )
],
id="by-flavfeel")
return body2
def render_page_content(pathname):
if pathname in ["", "/", "/dash", "/dash/table"]:
return table.layout
elif pathname == "/dash/map":
return map.layout
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == "/":
return about
elif pathname == "/dash":
return main.dashboard
elif pathname == "/prediction":
return predict.predict
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def get_model_desc(id):
return [
dbc.Row(
[
dbc.Jumbotron(
id = id,
style={'paddingBottom':'0.5rem','paddingTop':'0.8rem'}
),
],
justify="center"
),
]
def display_page(pathname):
if pathname == "/":
return layout
elif pathname == "/jira":
return jira.layout
elif pathname == "/github":
return github.layout
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def content_for_url(pathname):
if pathname == '/' or pathname == "/home":
return [
dcc.Markdown('''
This project is inspired and developed more from a subject, Data Analytics 3,
I studied in Lapland University of Applied Sciences, also my home university.
The original project is to work with **M Language** and **DAX** in **Power BI** to get used to analyzing data,
but I want to make the dashboard more interesting and accessible by
redoing them as my personal project with Python Dash plotly framework.
''')
]
if pathname == "/about":
return [
dcc.Markdown('''
I used callback function in Plotly/Dash framework to create interactive graphs
and CSS and Bootstraps to design layout of the websites. I also used Clustering algorithm to
group the countries based on the cultural difference index.
** How I calculate the cultural difference index:**
1. Fill the missing cultural index by calculating the adjacent/neigbour countries to it.
2. Calculate the difference by add up all the absolute of difference of each index in each country
and each index in your chosen country
3. Apply Machine Learning clustering method (KMeans algorithm) to define the countries group having the smallest difference
from you chosen one.
''')
]
if pathname == "/sources":
return [
dcc.Markdown('''
** Data Sources:**
1. Six metrics to measure a culture of a country: https://geerthofstede.com/research-and-vsm/dimension-data-matrix/
- Description: containing 6 metrics indicate the culture of a countries \[`pdi`, `idv`, `mas`, `uai`, `ltowvs`, `ivr`\]
2. Country and its bordering countries: https://en.wikipedia.org/wiki/List_of_countries_and_territories_by_land_borders
- Description: listing all the adjacent/neighbouring countries of a country.
** Document source:**
1. Dash plotly official website/document: https://dash.plotly.com/
- Description: I have all my neccessary information to build this project through this source.
2. Bootstrap with dash plotly official website/document: https://dash-bootstrap-components.opensource.faculty.ai/docs/
- Description: I learned about Bootstrap fundamental manipulation to layout the website.
''')
]
return dbc.Jumbotron([
html.H1("404: Not found"),
html.Hr(),
html.P("your url doesn't exist")
])
def display_page(pathname):
if pathname == '/':
return layout1
elif pathname == '/app2':
return layout2
elif pathname == '/app3':
return layout3
else:
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.H6(f"The pathname {pathname} was not recognised...")
])
def render_page_content(pathname):
if pathname in ["/", "/cross-type"]:
return cross_type
elif pathname == "/cross-situ":
return cross_situation
elif pathname == "/search":
return search
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def displayPageCallback(pathname):
print('displayPageCallback() pathname:', pathname)
if pathname == "/":
return indexLayout
elif pathname == '/uploadPage':
return uploadpage.uploadPageLayout
else:
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/", "/page-1"]:
return html.P("This is the content of page 1!")
elif pathname == "/page-2":
return html.P("This is the content of page 2. Yay!")
elif pathname == "/page-3":
return html.P("Oh cool, this is page 3!")
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def get_page_desc(_id):
"""Builds the first big text card that introduces users to the page"""
return [
dbc.Row([
dbc.Col([
dbc.Jumbotron(id=_id,
style={
'paddingBottom': '0.5rem',
'paddingTop': '0.8rem'
})
]),
])
]
def render_page_content(pathname):
if pathname == "/":
return home_page
elif pathname == "/page-1":
return html.P("filler")
elif pathname == "/page-2":
return html.P("filler")
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == "/":
return fighter_comparison.layout
elif pathname == "/ranking":
return all_time_ranking.layout
elif pathname == "/page-2":
return html.P("Oh cool, this is page 2!")
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/", "/page-1"]:
return html.Div(['Personal Studies of Dash App'])
elif pathname == "/page-2":
return stockapp.layout
elif pathname == "/page-3":
return want_a_gear.layout
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == '/':
return dbc.Jumbotron([
html.H1("Welcome!"),
html.Hr(),
html.P("Select a tab..."),
])
elif pathname == '/map':
return map_content()
elif pathname == '/schematics':
return render_schematics_content()
elif pathname == "/development":
return development_content('development')
elif pathname == "/gauges":
return gauges_content()
elif pathname == '/scenarios':
return development_content('scenarios')
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname == "/":
return html.P("This is the home page!")
elif pathname == "/calendar":
return html.P("This is your calendar... not much in the diary...")
elif pathname == "/messages":
return html.P("Here are all your messages")
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/", "/about"]:
return about.layout
elif pathname == "/daily-dashboard":
return daily_dashboard.layout
elif pathname == "/animations":
return animations.layout
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/", f"{requests_prefix}", f"{requests_prefix}metrics"]:
return metrics.layout
elif pathname == f"{requests_prefix}user-trends":
return user_trends.layout
elif pathname == f"{requests_prefix}reports":
return reports.layout
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/", "/home"]:
return home.content
elif pathname == "/project":
return project.content
elif pathname == "/team":
return team.content
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron([
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
])
def render_page_content(pathname):
if pathname in ["/"]:
return [assignments_page]
elif pathname[1:] in page_names:
return [page_names[pathname[1:]]]
# If the user tries to reach a different page, return a 404 message
return dbc.Jumbotron(
[
html.H1("404: Not found", className="text-danger"),
html.Hr(),
html.P(f"The pathname {pathname} was not recognised..."),
]
)