app.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

app.data_analysis() B

↳ Parent: app

Complexity

Conditions

Size

Total Lines	42
Code Lines	32

Duplication

Lines	42
Ratio	100 %

Importance

Changes

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

"""This module consists of all the functions utilized
for the Dash user interface."""

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,path,remove
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
import numpy as np

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

directory = './uploads'

if path.exists(directory):
    system("rm -r uploads")
#    remove(directory)
else:
    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.Br(),
        html.H2(
            children='Redox Properties',
            style={
                'color': colors['text']
            }
        ),
        dt.DataTable(
            rows=[{}],
            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'
            },
        )

])


def parse_contents(value):

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


def data_analysis(data):

    """This function returns a dictionary consisting of
    the relevant values. This can be seen in the user
    interface (Dash) as well."""
    results_dict = {}

    # df = main.data_frame(dict_1,1)
    x_val = data['Potential']
    y_val = data['Current']
    # Peaks are here [list]
    peak_index = peak_detection_fxn(y_val)

    # Split x,y to get baselines
    col_x1, col_x2 = split(x_val)

    col_y1, col_y2 = split(y_val)
    y_base1 = linear_background(col_x1, col_y1)

    y_base2 = linear_background(col_x2, col_y2)
    # Calculations based on baseline and peak
    values = peak_values(x_val, y_val)

    esub_t = values[0]
    esub_b = values[2]
    dof_e = del_potential(x_val, y_val)

    half_e = min(esub_t, esub_b) + half_wave_potential(x_val, y_val)

    ipa = peak_heights(x_val, y_val)[0]

    ipc = peak_heights(x_val, y_val)[1]
    ratio_i = peak_ratio(x_val, y_val)

    results_dict['Peak Current Ratio'] = ratio_i
    results_dict['Ipc (A)'] = ipc
    results_dict['Ipa (A)'] = ipa
    results_dict['Epc (V)'] = esub_b
    results_dict['Epa (V)'] = esub_t
    results_dict['∆E (V)'] = dof_e
    results_dict['Redox Potential (V)'] = half_e
    if dof_e > 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, col_x1, col_x2, col_y1, col_y2, y_base1, y_base2, peak_index
    #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.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):
    mypath='./uploads/'
    onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
    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):

    df = parse_contents(value)
    #print(df.head())
    #final_dict = data_analysis(df)
    final_dict, x_1, x_2, y_1, y_2, ybase_1, ybase_2, peak_i = data_analysis(df)
    df1=pd.DataFrame.from_records([final_dict])
    return df1.to_dict('records')


@app.callback(
    Output('CV_graph', 'figure'),
    [Input('files_dropdown', 'value')])
def update_figure(value):
    df = parse_contents(value)
    final_dict, x_1, x_2, y_1, y_2, ybase_1, ybase_2, peak_i = data_analysis(df)

    trace1 = go.Scatter(
            x = df['Potential'],
            y = df['Current'],
            marker={
                'size': 15,
                'opacity': 0.5,
                'color' : '#F00000'
            })
    trace2 = go.Scatter(
            x = x_1,
            y = ybase_1,
            mode = 'lines',
            line = dict(
                color = ('rgb(0, 0, 256)'),
                width = 3,
                dash = 'dash')
            )
    trace3 = go.Scatter(
            x = x_2,
            y = ybase_2,
            mode = 'lines',
            line = dict(
                color = ('rgb(0, 0, 256)'),
                width = 3,
                dash = 'dash')
            )
    trace4 = go.Scatter(
            x = np.array(x_1[peak_i[1]]),
            y = np.array(y_1[peak_i[1]]),
            mode = 'markers',
            marker={
                'size': 35,
                'opacity': 0.5,
                'color' : '#000080'
            })
    trace5 = go.Scatter(
            x = np.array(x_2[peak_i[0]]),
            y = np.array(y_2[peak_i[0]]),
            mode = 'markers',
            marker={
                'size': 35,
                'opacity': 0.5,
                'color' : '#000080'
            })
    data = [trace1, trace2, trace3, trace4, trace5]

    return {
        'data': data,
        #'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},
            showlegend = False,
            hovermode='closest',
        )
    }



#    return {
#        'data': [
#                {'x': [x1[peak_index[1]]], 'y': [x1[peak_index[1]]], 'type': 'point'},
#                #{'x': [1, 2, 3], 'y': [2, 4, 5], 'type': 'bar', 'name': u'Montréal'},
#            ],
#    }


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


1		"""This module consists of all the functions utilized
2		for the Dash user interface."""
3
4		import dash_resumable_upload
5		import dash
6		import dash_html_components as html
7		from dash.dependencies import Input, Output
8		import base64
9		from os import listdir,system,path,remove
10		import dash_table_experiments as dt
11		import dash_core_components as dcc
12		from os.path import isfile, join
13		import shutil
14		import time
15		import core
16		import io
17		import plotly.graph_objs as go
18		import pandas as pd
19		import numpy as np
20
21		#try:
22		# system("rm -r uploads")
23		#except:
24		# pass
25
26		directory = './uploads'
27
28		if path.exists(directory):
29		system("rm -r uploads")
30		# remove(directory)
31		else:
32		pass
33
34		app = dash.Dash('')
35
36		#external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css', 'https://codepen.io/rmarren1/pen/eMQKBW.css']
37		#app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
38
39		colors = {
40		'background': '#ECF0F1',
41		'text': '#800000'
42		}
43
44		image_filename = 'Logo.png' # replace with your own image
45		encoded_image = base64.b64encode(open(image_filename, 'rb').read()).decode('ascii')
46
47		dash_resumable_upload.decorate_server(app.server, "uploads")
48
49		app.scripts.config.serve_locally = True # Uploaded to npm, this can work online now too.
50
51
52		app.css.append_css({
53		"external_url": "https://codepen.io/rmarren1/pen/eMQKBW.css"
54		})
55
56		app.layout = html.Div(style={'backgroundColor': colors['background']}, children=[
57		html.H1(
58		children='VoltCycle',
59		style={
60		'textAlign': 'center',
61		'color': colors['text']
62		}
63		),
64
65		html.Div([
66		html.Img(draggable=True, style={
67		'height': '20%',
68		'width': '20%'
69		}, src='data:image/png;base64,{}'.format(encoded_image))
70		], style={'textAlign': 'center'}),
71
72		html.H2(children='A Tool for Accelerating the Analysis of Cyclic Voltammetry Data', style={
73		'textAlign': 'center',
74		'color': colors['text']
75		}),
76		html.Br(),
77		html.Div([
78		html.Link(rel='stylesheet', href='https://codepen.io/rmarren1/pen/eMQKBW.css'),
79		dash_resumable_upload.Upload(
80		id='upload',
81		maxFiles=1,
82		maxFileSize=102410241000, # 100 MB
83		service="/upload_resumable",
84		textLabel="Upload Files",
85		startButton=False)
86		]),
87		html.Div(id='output_uploaded_file'),
88		html.Br(),
89		html.H2(
90		children='Select File to Analyze',
91		style={
92		'textAlign': 'center',
93		'color': colors['text']
94		}
95		),
96		html.Div([
97		dcc.Dropdown(id='files_dropdown')
98		],style={'width': '70%', 'height': '40', 'display': 'inline-block', 'textAlign': 'center'}
99		),
100		html.Div([
101		html.Br(),
102		dcc.Graph(id='CV_graph'),
103		],style={
104		'columnCount': 1,
105		'width':'70%',
106		'height': '80%',
107		}
108		),
109
110
111		html.Div([
112		html.Br(),
113		html.H2(
114		children='Redox Properties',
115		style={
116		'color': colors['text']
117		}
118		),
119		dt.DataTable(
120		rows=[{}],
121		row_selectable=True,
122		filterable=True,
123		selected_row_indices=[],
124		id='datatable_initial'
125		),
126		html.Div(id='selected-indexes'),
127
128		],
129		style={
130		'width': '98%',
131		#'height': '60px',
132		#'lineHeight': '60px',
133		'margin': '10px'
134		},
135		)
136
137		])
138
139
140		def parse_contents(value):
141
142		if path.exists(directory):
143		lines1 = base64.b64encode(open("uploads/%s" % (value), 'rb').read())
144		lines2 = base64.b64decode(lines1).decode('utf-8').split('\n')
145		dict_1, n_cycle = core.read_file_dash(lines2)
146		#print(n_cycle)
147		df = core.data_frame(dict_1, 1)
148		return df
149
150
151	View Code Duplication	def data_analysis(data):
		0 ignored issues – show Duplication introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
152		"""This function returns a dictionary consisting of
153		the relevant values. This can be seen in the user
154		interface (Dash) as well."""
155		results_dict = {}
156
157		# df = main.data_frame(dict_1,1)
158		x_val = data['Potential']
159		y_val = data['Current']
160		# Peaks are here [list]
161		peak_index = peak_detection_fxn(y_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `peak_detection_fxn` does not seem to be defined. Loading history...
162		# Split x,y to get baselines
163		col_x1, col_x2 = split(x_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `split` does not seem to be defined. Loading history...
164		col_y1, col_y2 = split(y_val)
165		y_base1 = linear_background(col_x1, col_y1)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `linear_background` does not seem to be defined. Loading history...
166		y_base2 = linear_background(col_x2, col_y2)
167		# Calculations based on baseline and peak
168		values = peak_values(x_val, y_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `peak_values` does not seem to be defined. Loading history...
169		esub_t = values[0]
170		esub_b = values[2]
171		dof_e = del_potential(x_val, y_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `del_potential` does not seem to be defined. Loading history...
172		half_e = min(esub_t, esub_b) + half_wave_potential(x_val, y_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `half_wave_potential` does not seem to be defined. Loading history...
173		ipa = peak_heights(x_val, y_val)[0]
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `peak_heights` does not seem to be defined. Loading history...
174		ipc = peak_heights(x_val, y_val)[1]
175		ratio_i = peak_ratio(x_val, y_val)
		0 ignored issues – show Comprehensibility Best Practice introduced 2019-03-22 08:43 UTC by Report Bug Copy Issue Report The variable `peak_ratio` does not seem to be defined. Loading history...
176		results_dict['Peak Current Ratio'] = ratio_i
177		results_dict['Ipc (A)'] = ipc
178		results_dict['Ipa (A)'] = ipa
179		results_dict['Epc (V)'] = esub_b
180		results_dict['Epa (V)'] = esub_t
181		results_dict['∆E (V)'] = dof_e
182		results_dict['Redox Potential (V)'] = half_e
183		if dof_e > 0.3:
184		results_dict['Reversible'] = 'No'
185		else:
186		results_dict['Reversible'] = 'Yes'
187
188		if half_e > 0 and 'Yes' in results_dict.values():
189		results_dict['Type'] = 'Catholyte'
190		elif 'Yes' in results_dict.values():
191		results_dict['Type'] = 'Anolyte'
192		return results_dict, col_x1, col_x2, col_y1, col_y2, y_base1, y_base2, peak_index
193		#return results_dict
194
195
196		@app.callback(Output('output_uploaded_file', 'children'),
197		[Input('upload', 'fileNames')])
198		def display_files(fileNames):
199		if fileNames is not None:
200		return html.Ul([html.Li(html.A(x), style={'textAlign': 'center'}) for x in fileNames])
201		return html.Ul(html.Li("No Files Uploaded Yet!"), style={'textAlign': 'center'})
202
203
204		@app.callback(Output('files_dropdown', 'options'),
205		[Input('upload','fileNames')])
206		def dropdown_files(fileNames):
207		mypath='./uploads/'
208		onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
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		def update_table1(value):
216
217		df = parse_contents(value)
218		#print(df.head())
219		#final_dict = data_analysis(df)
220		final_dict, x_1, x_2, y_1, y_2, ybase_1, ybase_2, peak_i = data_analysis(df)
221		df1=pd.DataFrame.from_records([final_dict])
222		return df1.to_dict('records')
223
224
225		@app.callback(
226		Output('CV_graph', 'figure'),
227		[Input('files_dropdown', 'value')])
228		def update_figure(value):
229		df = parse_contents(value)
230		final_dict, x_1, x_2, y_1, y_2, ybase_1, ybase_2, peak_i = data_analysis(df)
231
232		trace1 = go.Scatter(
233		x = df['Potential'],
234		y = df['Current'],
235		marker={
236		'size': 15,
237		'opacity': 0.5,
238		'color' : '#F00000'
239		})
240		trace2 = go.Scatter(
241		x = x_1,
242		y = ybase_1,
243		mode = 'lines',
244		line = dict(
245		color = ('rgb(0, 0, 256)'),
246		width = 3,
247		dash = 'dash')
248		)
249		trace3 = go.Scatter(
250		x = x_2,
251		y = ybase_2,
252		mode = 'lines',
253		line = dict(
254		color = ('rgb(0, 0, 256)'),
255		width = 3,
256		dash = 'dash')
257		)
258		trace4 = go.Scatter(
259		x = np.array(x_1[peak_i[1]]),
260		y = np.array(y_1[peak_i[1]]),
261		mode = 'markers',
262		marker={
263		'size': 35,
264		'opacity': 0.5,
265		'color' : '#000080'
266		})
267		trace5 = go.Scatter(
268		x = np.array(x_2[peak_i[0]]),
269		y = np.array(y_2[peak_i[0]]),
270		mode = 'markers',
271		marker={
272		'size': 35,
273		'opacity': 0.5,
274		'color' : '#000080'
275		})
276		data = [trace1, trace2, trace3, trace4, trace5]
277
278		return {
279		'data': data,
280		#'layout' : {'Dash'}
281		'layout': go.Layout(
282		xaxis={'title': 'Voltage (V)'},
283		yaxis={'title': 'Current (A)'},
284		margin={'l': 40, 'b': 40, 't': 10, 'r': 10},
285		# #legend={'x': 0, 'y': 1},
286		showlegend = False,
287		hovermode='closest',
288		)
289		}
290
291
292
293		# return {
294		# 'data': [
295		# {'x': [x1[peak_index[1]]], 'y': [x1[peak_index[1]]], 'type': 'point'},
296		# #{'x': [1, 2, 3], 'y': [2, 4, 5], 'type': 'bar', 'name': u'Montréal'},
297		# ],
298		# }
299
300
301		if __name__ == '__main__':
302		app.run_server(debug=True)
303

sabiharustam / voltcycle

GitHub Access Token became invalid

Push — master ( 0c3829...de7c60 )

app.data_analysis() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like