def init_app():
server = flask.Flask(__name__, instance_relative_config=True)
server.config.from_object('config')
server.config.from_pyfile('config.py')
cache.init_app(server)
scheduler.init_app(server)
app = dash.Dash(__name__,
server=server,
external_stylesheets=[dbc.themes.BOOTSTRAP],
title='SWAT Viewer',
requests_pathname_prefix=f'{server.config["APP_ROOT"]}')
du.configure_upload(
app,
server.config['UPLOAD_FOLDER_ROOT'],
)
app.layout = maintabs
# add call backs
add_callbacks(app)
# add scheduler
add_scheduler(scheduler)
scheduler.start()
return app
def register_callbacks(app, cache, fsc):
logging.warning('Register callbacks')
upload_root = os.getenv('MINT_DATA_DIR', tempfile.gettempdir())
upload_dir = str(P(upload_root) / 'MINT-Uploads')
UPLOAD_FOLDER_ROOT = upload_dir
du.configure_upload(app, UPLOAD_FOLDER_ROOT)
messages.callbacks(app=app, fsc=fsc, cache=cache)
for module in _modules:
func = module.callbacks
if func is not None:
func(app=app, fsc=fsc, cache=cache)
# Updates the current viewport
app.clientside_callback(
"""
function(href) {
var w = window.innerWidth;
var h = window.innerHeight;
return `${w},${h}` ;
}
""", Output('viewport-container', 'children'),
Input('progress-interval', 'n_intervals'))
@app.callback(Output('tab-content', 'children'), Input('tab', 'value'),
State('wdir', 'children'))
def render_content(tab, wdir):
func = modules[tab].layout
if tab != 'Workspaces' and wdir == '':
return dbc.Alert('Please, create and activate a workspace.',
color='warning')
elif tab in ['Metadata', 'Peak Optimization', 'Processing'] and len(
T.get_ms_fns(wdir)) == 0:
return dbc.Alert('Please import MS files.', color='warning')
elif tab in ['Processing'] and (len(T.get_targets(wdir)) == 0):
return dbc.Alert('Please, define targets.', color='warning')
elif tab in ['Analysis'] and not P(T.get_results_fn(wdir)).is_file():
return dbc.Alert('Please, create results (Processing).',
color='warning')
if func is not None:
return func()
else:
raise PreventUpdate
@app.callback(Output('tmpdir', 'children'), Output('logout-button',
'style'),
Input('progress-interval', 'n_intervals'))
def upate_tmpdir(x):
if hasattr(app.server, 'login_manager'):
username = current_user.username
logging.warning(f'User: {username}')
tmpdir = str(TMPDIR / 'User' / username)
logging.warning(tmpdir)
return tmpdir, {'visibility': 'visible'}
logging.info('Hide login button')
return str(TMPDIR / 'Local'), {'visibility': 'hidden'}
import dash
import dash_bootstrap_components as dbc
import dash_html_components as html
from dash.dependencies import Input, Output, State
import dash_uploader as du
import os
from flask import send_from_directory
import time
app = dash.Dash(__name__, suppress_callback_exceptions=True)
du.configure_upload(app, 'NetDisk', use_upload_id=False)
app.layout = html.Div(
dbc.Container([
html.H3('简易的个人云盘应用'),
html.Hr(),
html.P('文件上传区：'),
du.Upload(id='upload',
text='点击或拖动文件到此进行上传！',
text_completed='已完成上传文件：',
max_files=1000),
html.Hr(),
dbc.Row([
dbc.Button('删除选中的文件', id='delete-btn', outline=True),
dbc.Button('打包下载选中的文件', id='download-btn', outline=True)
]),
html.Hr(),
dbc.Spinner(dbc.Checklist(id='file-list-check')),
html.A(id='download-url', target='_blank')
]))
from dash.dependencies import Input, Output
import plotly.express as px
import plotly.graph_objects as go
from sklearn.manifold import TSNE
from chord import Chord
from sklearn import (manifold, datasets, decomposition, ensemble,
discriminant_analysis, random_projection, neighbors)
import dash_uploader as du
import uuid
from sklearn.decomposition import PCA
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
UPLOAD_FOLDER_ROOT = r"C:\tmp\Uploads"
du.configure_upload(app, UPLOAD_FOLDER_ROOT)
# make a sample data frame with 6 columns
np.random.seed(0)
df_iris = datasets.load_iris()
df = df_iris.data
df = pd.DataFrame(df)
#pca = PCA()
#pca.fit(df)
#exp_var_cumul = np.cumsum(pca.explained_variance_ratio_)
#x=range(1, exp_var_cumul.shape[0] + 1)
app.layout = html.Div(
[
# empty Div to trigger javascript file for graph resizing
vid = open(fn_pre, 'rb')
base64_data = b64encode(vid.read())
base64_string = base64_data.decode('utf-8')
return [html.Video(src=f'data:video/webm;base64,{base64_string}', controls=True)], f'/{ffname}', False
return app
if __name__ == '__main__':
external_stylesheets = [
dbc.themes.BOOTSTRAP,
]
server = Flask(__name__)
app = Dash(__name__, server=server, external_stylesheets=external_stylesheets)
app.config['suppress_callback_exceptions'] = True
@app.server.route('/downloads/<path:path>')
def serve_static(path):
return send_from_directory(
Path("downloads"), path, as_attachment=True
)
du.configure_upload(app, Path.cwd() / Path("temp"))
app.layout = layout
app = add_dash(app)
app.run_server(debug=True)
if DEBUG:
import shutil
try:
shutil.rmtree(str(UPLOADPATH))
except FileNotFoundError:
pass
UPLOADPATH.mkdir(parents=False, exist_ok=True)
app = dash.Dash(
__name__,
suppress_callback_exceptions=
True, # disable callback vaidations to enable dynamic modification
external_stylesheets=[dbc.themes.BOOTSTRAP])
# configure the upload folder
du.configure_upload(app, UPLOADPATH)
CACHE_CONFIG = {
'CACHE_TYPE': 'filesystem',
'CACHE_DIR': 'cache-directory',
# should be equal to maximum number of users on the app at a single time
# higher numbers will store more data in the filesystem / redis cache
'CACHE_THRESHOLD': 10
}
# cache = Cache()
# cache.init_app(app.server, config=CACHE_CONFIG)
# cache.clear()
env['UPLOADPATH'] = str(UPLOADPATH)
app.layout = serve_layout()
register_callbacks(app)
import dash_bootstrap_components as dbc
import dash_uploader as du
import plotly.graph_objects as go
from PIL import Image
from python import xai
BS = "https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css"
app = dash.Dash(
__name__, external_stylesheets=[BS], assets_folder=os.getcwd() + "/assets/static"
)
du.configure_upload(app, "temp", use_upload_id=False)
navbar = dbc.NavbarSimple(
children=[
dbc.NavItem(
dbc.NavLink(
"Dog Dataset",
href="https://s3-us-west-1.amazonaws.com/udacity-aind/dog-project/dogImages.zip",
)
),
dbc.NavItem(
dbc.NavLink("DenseNet-121", href="https://arxiv.org/abs/1608.06993")
),
dbc.NavItem(dbc.NavLink("Grad-CAM", href="https://arxiv.org/abs/1610.02391")),
],
brand="Explainable Artificial Intelligence Webapp",
import globals
import dash_uploader as du
app.layout = html.Div(
[dcc.Location(id='url', refresh=False),
html.Div(id='page-content')])
@app.callback(dash.dependencies.Output('page-content', 'children'),
[dash.dependencies.Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/apps/dsAndAlgos':
return dsAndAlgosPage
elif pathname == '/apps/datasets':
return datasetsPage
elif pathname == '/apps/algorithms':
return algorithmsPage
else:
return dsAndAlgosPage # This is the "default page"
if __name__ == '__main__':
globals.yoloInstance.load_network()
# Dash uploader creates folder if it does not exist
du.configure_upload(app, globals.upload_dir)
app.run_server(debug=False, dev_tools_hot_reload=False)
if not os.path.exists(DOWNLOAD_DIRECTORY):
os.makedirs(DOWNLOAD_DIRECTORY)
if not os.path.exists(LOG_DIRECTORY):
os.makedirs(LOG_DIRECTORY)
with open(LOG_DIRECTORY+'/app.log', 'w') as fp:
pass
logging.basicConfig(filename=LOG_DIRECTORY+'/app.log', format='%(asctime)s %(levelname)s: %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO)
# Normally, Dash creates its own Flask server internally. By creating our own,
# we can create a route for downloading files directly:
server = Flask(__name__)
app = dash.Dash(server=server, external_stylesheets=[dbc.themes.BOOTSTRAP])
du.configure_upload(app, UPLOAD_DIRECTORY)
@server.route("/downloads/<path:path>")
def download(path):
"""Serve a file from the upload directory."""
return send_from_directory(DOWNLOAD_DIRECTORY, path, as_attachment=True)
@server.route("/list")
def list():
filelist = uploaded_files()
return '<br>'.join(filelist)
@server.route("/deleteall")
def deleteall():
delete_folder(DOWNLOAD_DIRECTORY)
import dash
import dash_uploader as du
import dash_bootstrap_components as dbc
import dash_html_components as html
from dash.dependencies import Input, Output, State
app = dash.Dash(__name__)
# 配置上传文件夹
du.configure_upload(app, folder='temp')
app.layout = html.Div(
dbc.Container(
[du.Upload(id='uploader'),
html.H5('上传中或还未上传文件！', id='upload_status')]))
@app.callback(Output('upload_status', 'children'),
Input('uploader', 'isCompleted'), State('uploader', 'fileNames'))
def show_upload_status(isCompleted, fileNames):
if isCompleted:
return '已完成上传：' + fileNames[0]
return dash.no_update
if __name__ == '__main__':
app.run_server(debug=True, port=8051)
import dash
import dash_core_components as dcc
import dash_bootstrap_components as dbc
import dash_html_components as html
import dash_uploader as du
from dash.dependencies import Input, Output, State
from MainApp import app
du.configure_upload(app, 'data/',use_upload_id=False)
tab_style = {
'backgroundColor': '#d3e0ea',
'color': 'rgb(70, 79, 85)'
}
tab_selected_style = {
'backgroundColor': 'rgb(70, 162, 187)',
'color': 'white',
}
app.layout = html.Div([
html.Div(
className="navbar",
children=[
html.H3(
children="Interactive Data Analytics Dashboard for RDF Knowledge Graphs",
className="navbar--title"),
html.Div(
children=[
from flask import session
from components.ippd_fw import InteractiveProcessDriftDetectionFW
import uuid
app = dash.Dash(__name__,
external_stylesheets=[dbc.themes.FLATLY],
meta_tags=[{
'name': 'viewport',
'content': 'width=device-width, initial-scale=1.0'
}],
suppress_callback_exceptions=True)
framework = InteractiveProcessDriftDetectionFW(model_type='dfg')
app.title = 'IPDD Framework'
# configure the upload folder
du.configure_upload(app, framework.get_input_path())
server = app.server
app.server.secret_key = b'e\x19\xf5\xcaZ\x89\xff\xf4\xbf\x15\x14S.\x931\xbd'
def get_user_id():
# recover the user from session
user = '******'
if not session.get('user'):
print(f'Creating user session...')
user = str(uuid.uuid4())
session['user'] = user
elif session.get('user'):
user = session['user']
# print(f'Get user from session {user}')
return user
import base64
from datetime import datetime as dt
from app import navbar as navbar
from app import app
import calculation as calculation
import dash_uploader as du
temp_upload_directory = r"./monthly_data/uploads/temp/"
temp_upload_directory_abs = os.path.abspath(
temp_upload_directory).replace('\\', '/') + '/'
du.configure_upload(app, temp_upload_directory, use_upload_id=False)
# cache = Cache(app.server, config={
# # try 'filesystem' if you don't want to setup redis
# 'CACHE_TYPE': 'redis',
# 'CACHE_REDIS_URL': os.environ.get('REDIS_URL', '')
# })
directories = [a for a in os.listdir(
'./monthly_data/uploads/') if a != '.gitkeep']
column_style = {'height': '60vh',
'gridTemplateColumns': '100%',
'display': 'grid',
'alignItems': 'center',
'justifyContent': 'center',
import dash
from flask_caching import Cache
import dash_uploader as du
app = dash.Dash(__name__, suppress_callback_exceptions=True)
app.title = 'LRGASP quantification evaluation'
config = {
"DEBUG": True, # some Flask specific configs
"CACHE_TYPE": "simple", # Flask-Caching related configs
"CACHE_DEFAULT_TIMEOUT": 300
}
cache = Cache()
du.configure_upload(app, r"tmp")
cache.init_app(app.server, config=config)
from flask import send_from_directory
import dash
import dash_uploader as du
import dash_html_components as html
import dash_bootstrap_components as dbc
from dash.dependencies import Input, Output
import os
app = dash.Dash(__name__)
du.configure_upload(app, 'temp', use_upload_id=False)
app.layout = html.Div(
dbc.Container([du.Upload(id='upload'),
html.Div(id='download-files')]))
@app.server.route('/download/<file>')
def download(file):
return send_from_directory('temp', file)
@app.callback(Output('download-files', 'children'),
Input('upload', 'isCompleted'))
def render_download_url(isCompleted):
if isCompleted:
return html.Ul([
html.Li(
html.A(f'/{file}', href=f'/download/{file}', target='_blank'))
from dash.dependencies import Input, Output, State
import dash_table
import dash_uploader as du
import re
import os
import pandas as pd
from sqlalchemy import create_engine
import cchardet as chardet
postgres_url = 'postgresql://*****:*****@localhost:5432/Dash'
engine = create_engine(postgres_url)
app = dash.Dash(__name__)
du.configure_upload(app, 'upload')
app.layout = html.Div(
dbc.Container(
[
du.Upload(id='upload',
filetypes=['csv'],
text='点击或拖动文件到此进行上传！',
text_completed='已完成上传文件：',
cancel_button=True,
pause_button=True),
html.Hr(),
dbc.Form([
dbc.FormGroup([
dbc.Label("设置入库表名", html_for="table-name"),
dbc.Input(id='table-name', autoComplete='off'),
from bs4 import BeautifulSoup as bs
if platform.system() == 'Windows':
cachepath = '\\cache\\'
dfpath = '\\feathereddataframes\\'
figurepath = '\\pickledfigures\\'
topopath = '\\topo\\'
else:
cachepath = '/cache/'
dfpath = '/feathereddataframes/'
topopath = '/topo/'
packagepath = pathlib.Path(__file__).parent.parent.resolve()
du.configure_upload(
app,
str(packagepath) + cachepath,
use_upload_id=False,
)
'''
Contents:
1 - Dropdown population
- Generic placeholder generation, fired on server startup
2 - File upload
- makedataframe()
3 - Data pre-processing
- preprocessdata()
- compares dataframes and checks for intra and inter file errors
4 - Figure management
- clearprogramdata()
- clears out files from rats/feathereddataframes and rats/pickledfigures
5 - Server shutdown
import gdown
from styles import SIDEBAR_STYLE, CONTENT_STYLE, LOGO_STYLE
import json
import scvi
import scanpy as sc
import time
sc.set_figure_params(figsize=(4, 4))
app = dash.Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])
du.configure_upload(app, r"./data")
sidebar = html.Div(
[
html.Img(src="https://docs.scvi-tools.org/en/stable/_static/logo.png",
style=LOGO_STYLE),
html.Hr(),
html.P("A gui for scvi.", className="lead"),
dbc.Nav(
[
dbc.NavLink("Upload Data", href="/", active="exact"),
dbc.NavLink("Preprocess", href="/preprocess", active="exact"),
dbc.NavLink(
"Setup anndata", href="/setup-anndata", active="exact"),
dbc.NavLink("Train model", href="/train-model",
active="exact"),
