final_dash.data_analysis() - Code Metrics - Inspection of "pylinted everything" - sabiharustam/voltcycle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0c3829...de7c60 )

by Keertana

created 2019-03-22 08:41 UTC

final_dash.data_analysis() B

↳ Parent: final_dash

Complexity

Conditions

Size

Total Lines	39
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	32
dl	0
loc	39
rs	8.6453
c	0
b	0
f	0
cc	5
nop	1

import dash_resumable_upload
import dash
import dash_html_components as html
from dash.dependencies import Input, Output
import base64
from os import listdir,system
import dash_table_experiments as dt
import dash_core_components as dcc
from os.path import isfile, join
import shutil
import time
import core
import io
import plotly.graph_objs as go
import pandas as pd

try:
    system("rm -r uploads")
except:
    pass

app = dash.Dash('')

#external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css', 'https://codepen.io/rmarren1/pen/eMQKBW.css']
#app = dash.Dash(__name__, external_stylesheets=external_stylesheets)

colors = {
    'background': '#ECF0F1',
    'text': '#800000'
}

image_filename = 'Logo.png' # replace with your own image
encoded_image = base64.b64encode(open(image_filename, 'rb').read()).decode('ascii')

dash_resumable_upload.decorate_server(app.server, "uploads")

app.scripts.config.serve_locally = True  # Uploaded to npm, this can work online now too.


#app.css.append_css({
#    "external_url": "https://codepen.io/rmarren1/pen/eMQKBW.css"
#})

app.layout = html.Div(style={'backgroundColor': colors['background']}, children=[
    html.H1(
        children='VoltCycle',
        style={
            'textAlign': 'center',
            'color': colors['text']
        }
    ),

    html.Div([
        html.Img(draggable=True, style={
                'height': '20%',
                'width': '20%'
            },  src='data:image/png;base64,{}'.format(encoded_image))
   ], style={'textAlign': 'center'}),

    html.H2(children='A Tool for Accelerating the Analysis of Cyclic Voltammetry Data', style={
        'textAlign': 'center',
        'color': colors['text']
    }),
    html.Br(),
    html.Div([
    html.Link(rel='stylesheet', href='https://codepen.io/rmarren1/pen/eMQKBW.css'),
    dash_resumable_upload.Upload(
        id='upload',
        maxFiles=1,
        maxFileSize=1024*1024*1000,  # 100 MB
        service="/upload_resumable",
        textLabel="Upload Files",
        startButton=False)
    ]),
    html.Div(id='output_uploaded_file'),
    html.Br(),
    html.H2(
        children='Select File to Analyze',
        style={
            'textAlign': 'center',
            'color': colors['text']
        }
    ),
    html.Div([
       dcc.Dropdown(id='files_dropdown')
       ],style={'width': '70%', 'height': '40', 'display': 'inline-block', 'textAlign': 'center'}
    ),
    html.Div([
        html.Br(),
        dcc.Graph(id='CV_graph'),
        ],style={
            'columnCount': 1,
            'width':'70%',
            'height': '80%',
            }
    ),
       

    html.Div([
        html.H4(
            children='CV DataTable',
            style={
                'textAlign': 'center',
                'color': colors['text']
            }
        ),
        dt.DataTable(
            #rows=charge.to_dict('records'), #converts df to dict
            rows=[{}],
            #columns=sorted(charge.columns), #sorts columns
            row_selectable=True,
            filterable=True,
            selected_row_indices=[],
            id='datatable_initial'
            ),
        html.Div(id='selected-indexes'),

        ],
        style={
            'width': '98%',
            #'height': '60px',
            #'lineHeight': '60px',
            'margin': '10px'
            },
        )

])


    #encode = base64.b64encode(
    #    open("uploads/%s" % (x), 'rb').read()).decode('ascii')
    #return "data:image/jpg;base64,{}".format(encode)


def parse_contents(value):

    lines1 = base64.b64encode(open("uploads/%s" % (value), 'rb').read())
    lines2 = base64.b64decode(lines1).decode('utf-8').split('\n')
    #lines2 = lines1.decode('utf-8')
    #lines = io.StringIO(lines2)
    dict_1, n_cycle = core.read_file_dash(lines2)
    print(n_cycle)
    df = core.data_frame(dict_1, 1)
    return df


def data_analysis(df):
    results_dict = {}

    # df = main.data_frame(dict_1,1)
    x = df['Potential']
    y = df['Current']
    # Peaks are here [list]
    peak_index = core.peak_detection_fxn(y)
    # Split x,y to get baselines
    x1,x2 = core.split(x)
    y1,y2 = core.split(y)
    y_base1 = core.linear_background(x1,y1)
    y_base2 = core.linear_background(x2,y2)
    # Calculations based on baseline and peak
    values = core.peak_values(x,y)
    Et = values[0]
    Eb = values[2]
    dE = core.del_potential(x,y)
    half_E = min(Et,Eb) + core.half_wave_potential(x,y)
    ia = core.peak_heights(x,y)[0]
    ic = core.peak_heights(x,y)[1]
    ratio_i = core.peak_ratio(x,y)
    results_dict['Peak Current Ratio'] = ratio_i
    results_dict['Ipc'] = ic
    results_dict['Ipa'] = ia
    results_dict['Epc'] = Eb
    results_dict['Epa'] = Et
    results_dict['∆E'] = dE
    results_dict['Redox Potential'] = half_E
    if dE>0.3:
        results_dict['Reversible'] = 'No'
    else:
        results_dict['Reversible'] = 'Yes'
    
    if half_E>0 and  'Yes' in results_dict.values():
        results_dict['Type'] = 'Catholyte'
    elif 'Yes' in results_dict.values():
        results_dict['Type'] = 'Anolyte'
    return results_dict


@app.callback(Output('output_uploaded_file', 'children'),
              [Input('upload', 'fileNames')])
def display_files(fileNames):
    if fileNames is not None:
        #return html.Ul([html.Li(
         #   html.Img(height="50", width="100", src=get_img(x))) for x in fileNames])
        return html.Ul([html.Li(html.A(x), style={'textAlign': 'center'}) for x in fileNames])
    return html.Ul(html.Li("No Files Uploaded Yet!"), style={'textAlign': 'center'})


@app.callback(Output('files_dropdown', 'options'),

              [Input('upload','fileNames')])
def dropdown_files(fileNames):
#    time.sleep(5)
    mypath='./uploads/'
    onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
   #print(onlyfiles)
        #onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
    #options=[{'label': i, 'value': i} for i in onlyfiles]
    #print(options)
    #return {'options':options}
    return [{'label': i, 'value': i} for i in onlyfiles]


@app.callback( #update charge datatable
    Output('datatable_initial', 'rows'),
    [Input('files_dropdown', 'value')])

def update_table1(value):
    #for line in lines3:
    #    print(line)
    #print(type(lines3))
    df = parse_contents(value)
    print(df.head())
    final_dict = data_analysis(df)
    #print(final_dict)
    #df1 = pd.DataFrame.from_dict(final_dict)
    df1=pd.DataFrame.from_records([final_dict])
    #print(df1)
    #data = parse_contents(contents, filename, date)
    #charge, discharge = ccf.sep_char_dis(data)
    return df1.to_dict('records')

@app.callback(
    Output('CV_graph', 'figure'),
    [Input('files_dropdown', 'value')])
def update_figure(value):
    df = parse_contents(value)

    return {
        'data': [go.Scatter(
            x = df['Potential'],
            y = df['Current'],
            marker={
                'size': 15,
                'opacity': 0.5,
                'color' : '#FF851B'
            }
        )],
        #'layout' : {'Dash'}
        'layout': go.Layout(
            xaxis={'title': 'Voltage (V)'},
            yaxis={'title': 'Current (A)'},
            margin={'l': 40, 'b': 40, 't': 10, 'r': 10},
        #    #legend={'x': 0, 'y': 1},
            hovermode='closest',
        )
    }


if __name__ == '__main__':
    app.run_server(debug=True)


1		import dash_resumable_upload
2		import dash
3		import dash_html_components as html
4		from dash.dependencies import Input, Output
5		import base64
6		from os import listdir,system
7		import dash_table_experiments as dt
8		import dash_core_components as dcc
9		from os.path import isfile, join
10		import shutil
11		import time
12		import core
13		import io
14		import plotly.graph_objs as go
15		import pandas as pd
16
17		try:
18		system("rm -r uploads")
19		except:
20		pass
21
22		app = dash.Dash('')
23
24		#external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css', 'https://codepen.io/rmarren1/pen/eMQKBW.css']
25		#app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
26
27		colors = {
28		'background': '#ECF0F1',
29		'text': '#800000'
30		}
31
32		image_filename = 'Logo.png' # replace with your own image
33		encoded_image = base64.b64encode(open(image_filename, 'rb').read()).decode('ascii')
34
35		dash_resumable_upload.decorate_server(app.server, "uploads")
36
37		app.scripts.config.serve_locally = True # Uploaded to npm, this can work online now too.
38
39
40		#app.css.append_css({
41		# "external_url": "https://codepen.io/rmarren1/pen/eMQKBW.css"
42		#})
43
44		app.layout = html.Div(style={'backgroundColor': colors['background']}, children=[
45		html.H1(
46		children='VoltCycle',
47		style={
48		'textAlign': 'center',
49		'color': colors['text']
50		}
51		),
52
53		html.Div([
54		html.Img(draggable=True, style={
55		'height': '20%',
56		'width': '20%'
57		}, src='data:image/png;base64,{}'.format(encoded_image))
58		], style={'textAlign': 'center'}),
59
60		html.H2(children='A Tool for Accelerating the Analysis of Cyclic Voltammetry Data', style={
61		'textAlign': 'center',
62		'color': colors['text']
63		}),
64		html.Br(),
65		html.Div([
66		html.Link(rel='stylesheet', href='https://codepen.io/rmarren1/pen/eMQKBW.css'),
67		dash_resumable_upload.Upload(
68		id='upload',
69		maxFiles=1,
70		maxFileSize=102410241000, # 100 MB
71		service="/upload_resumable",
72		textLabel="Upload Files",
73		startButton=False)
74		]),
75		html.Div(id='output_uploaded_file'),
76		html.Br(),
77		html.H2(
78		children='Select File to Analyze',
79		style={
80		'textAlign': 'center',
81		'color': colors['text']
82		}
83		),
84		html.Div([
85		dcc.Dropdown(id='files_dropdown')
86		],style={'width': '70%', 'height': '40', 'display': 'inline-block', 'textAlign': 'center'}
87		),
88		html.Div([
89		html.Br(),
90		dcc.Graph(id='CV_graph'),
91		],style={
92		'columnCount': 1,
93		'width':'70%',
94		'height': '80%',
95		}
96		),
97
98
99		html.Div([
100		html.H4(
101		children='CV DataTable',
102		style={
103		'textAlign': 'center',
104		'color': colors['text']
105		}
106		),
107		dt.DataTable(
108		#rows=charge.to_dict('records'), #converts df to dict
109		rows=[{}],
110		#columns=sorted(charge.columns), #sorts columns
111		row_selectable=True,
112		filterable=True,
113		selected_row_indices=[],
114		id='datatable_initial'
115		),
116		html.Div(id='selected-indexes'),
117
118		],
119		style={
120		'width': '98%',
121		#'height': '60px',
122		#'lineHeight': '60px',
123		'margin': '10px'
124		},
125		)
126
127		])
128
129
130		#encode = base64.b64encode(
131		# open("uploads/%s" % (x), 'rb').read()).decode('ascii')
132		#return "data:image/jpg;base64,{}".format(encode)
133
134
135		def parse_contents(value):
136
137		lines1 = base64.b64encode(open("uploads/%s" % (value), 'rb').read())
138		lines2 = base64.b64decode(lines1).decode('utf-8').split('\n')
139		#lines2 = lines1.decode('utf-8')
140		#lines = io.StringIO(lines2)
141		dict_1, n_cycle = core.read_file_dash(lines2)
142		print(n_cycle)
143		df = core.data_frame(dict_1, 1)
144		return df
145
146
147		def data_analysis(df):
148		results_dict = {}
149
150		# df = main.data_frame(dict_1,1)
151		x = df['Potential']
152		y = df['Current']
153		# Peaks are here [list]
154		peak_index = core.peak_detection_fxn(y)
155		# Split x,y to get baselines
156		x1,x2 = core.split(x)
157		y1,y2 = core.split(y)
158		y_base1 = core.linear_background(x1,y1)
159		y_base2 = core.linear_background(x2,y2)
160		# Calculations based on baseline and peak
161		values = core.peak_values(x,y)
162		Et = values[0]
163		Eb = values[2]
164		dE = core.del_potential(x,y)
165		half_E = min(Et,Eb) + core.half_wave_potential(x,y)
166		ia = core.peak_heights(x,y)[0]
167		ic = core.peak_heights(x,y)[1]
168		ratio_i = core.peak_ratio(x,y)
169		results_dict['Peak Current Ratio'] = ratio_i
170		results_dict['Ipc'] = ic
171		results_dict['Ipa'] = ia
172		results_dict['Epc'] = Eb
173		results_dict['Epa'] = Et
174		results_dict['∆E'] = dE
175		results_dict['Redox Potential'] = half_E
176		if dE>0.3:
177		results_dict['Reversible'] = 'No'
178		else:
179		results_dict['Reversible'] = 'Yes'
180
181		if half_E>0 and 'Yes' in results_dict.values():
182		results_dict['Type'] = 'Catholyte'
183		elif 'Yes' in results_dict.values():
184		results_dict['Type'] = 'Anolyte'
185		return results_dict
186
187
188		@app.callback(Output('output_uploaded_file', 'children'),
189		[Input('upload', 'fileNames')])
190		def display_files(fileNames):
191		if fileNames is not None:
192		#return html.Ul([html.Li(
193		# html.Img(height="50", width="100", src=get_img(x))) for x in fileNames])
194		return html.Ul([html.Li(html.A(x), style={'textAlign': 'center'}) for x in fileNames])
195		return html.Ul(html.Li("No Files Uploaded Yet!"), style={'textAlign': 'center'})
196
197
198	View Code Duplication	@app.callback(Output('files_dropdown', 'options'),
		0 ignored issues – show Duplication introduced 2019-03-18 22:56 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
199		[Input('upload','fileNames')])
200		def dropdown_files(fileNames):
201		# time.sleep(5)
202		mypath='./uploads/'
203		onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
204		#print(onlyfiles)
205		#onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
206		#options=[{'label': i, 'value': i} for i in onlyfiles]
207		#print(options)
208		#return {'options':options}
209		return [{'label': i, 'value': i} for i in onlyfiles]
210
211
212		@app.callback( #update charge datatable
213		Output('datatable_initial', 'rows'),
214		[Input('files_dropdown', 'value')])
215
216		def update_table1(value):
217		#for line in lines3:
218		# print(line)
219		#print(type(lines3))
220		df = parse_contents(value)
221		print(df.head())
222		final_dict = data_analysis(df)
223		#print(final_dict)
224		#df1 = pd.DataFrame.from_dict(final_dict)
225		df1=pd.DataFrame.from_records([final_dict])
226		#print(df1)
227		#data = parse_contents(contents, filename, date)
228		#charge, discharge = ccf.sep_char_dis(data)
229		return df1.to_dict('records')
230
231		@app.callback(
232		Output('CV_graph', 'figure'),
233		[Input('files_dropdown', 'value')])
234		def update_figure(value):
235		df = parse_contents(value)
236
237		return {
238		'data': [go.Scatter(
239		x = df['Potential'],
240		y = df['Current'],
241		marker={
242		'size': 15,
243		'opacity': 0.5,
244		'color' : '#FF851B'
245		}
246		)],
247		#'layout' : {'Dash'}
248		'layout': go.Layout(
249		xaxis={'title': 'Voltage (V)'},
250		yaxis={'title': 'Current (A)'},
251		margin={'l': 40, 'b': 40, 't': 10, 'r': 10},
252		# #legend={'x': 0, 'y': 1},
253		hovermode='closest',
254		)
255		}
256
257
258		if __name__ == '__main__':
259		app.run_server(debug=True)
260

sabiharustam / voltcycle

GitHub Access Token became invalid

Push — master ( 0c3829...de7c60 )

final_dash.data_analysis() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like