def draw_map_image(self): df = pd.read_csv( 'https://raw.githubusercontent.com/plotly/datasets/master/2014_world_gdp_with_codes.csv' ) fig = go.Figure(data=go.Choropleth( locations=df['CODE'], z=self.df['cluster'], text=self.df['country'], colorscale='Blues', autocolorscale=False, reversescale=True, marker_line_color='darkgray', marker_line_width=0.5, colorbar_title='Cluster Group', )) fig.update_layout(title_text='K Means Clustering Visualization', geo=dict(showframe=True, showcoastlines=False, projection_type='equirectangular'), annotations=[ dict(x=0.55, y=0.1, xref='paper', yref='paper', showarrow=False) ]) py.sign_in("shirbendor", "ByDLoTeQOewal6U26ATM") py.image.save_as(fig, filename="./map.png")
def init_plotly_stream(): # init credentials with open('./credentials.json') as credentials_file: plotly_user_config = json.load(credentials_file) # authenticate with provided credentials plot.sign_in(plotly_user_config["plotly_username"], plotly_user_config["plotly_api_key"]) # configure the plot url = plot.plot([{ 'x': [], 'y': [], 'type': 'scatter', 'mode': 'lines+markers', 'stream': { 'token': plotly_user_config['plotly_streaming_tokens'][0], 'maxpoints': 200 }, }], filename='MS-Temperature') print("View your streaming graph here: ", url) # attach a stream to the plot stream = plot.Stream(plotly_user_config['plotly_streaming_tokens'][0]) return stream
def test_stream_unstreamable(self): # even though `name` isn't streamable, we don't validate it --> pass py.sign_in(un, ak) my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1], y=[10], name="nope")) my_stream.close()
def test_initialize_stream_plot(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') assert url == 'https://plot.ly/~PythonAPI/461' time.sleep(.5)
def test_sign_in(self): un = 'anyone' ak = 'something' # TODO, add this! # si = ['this', 'and-this'] py.sign_in(un, ak) creds = py.get_credentials() self.assertEqual(creds['username'], un) self.assertEqual(creds['api_key'], ak)
def test_initialize_stream_plot(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') assert url == 'https://plot.ly/~PythonAPI/461' time.sleep(.5)
def test_stream_unstreamable(self): # even though `name` isn't streamable, we don't validate it --> pass py.sign_in(un, ak) my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1], y=[10], name='nope')) my_stream.close()
def test_sign_in(self): un = 'anyone' ak = 'something' # TODO, add this! # si = ['this', 'and-this'] py.sign_in(un, ak) creds = py.get_credentials() self.assertEqual(creds['username'], un) self.assertEqual(creds['api_key'], ak)
def test_sign_in(self): un = "anyone" ak = "something" # TODO, add this! # si = ['this', 'and-this'] py.sign_in(un, ak) creds = py.get_credentials() self.assertEqual(creds["username"], un) self.assertEqual(creds["api_key"], ak)
def plot_graph(test_accuracy): py.sign_in('VikramShenoy', 'x1Un4yD3HDRT838vRkFA') training_accuracy = [] history = np.load("history.npy", allow_pickle=True) training_loss = history.item().get('train_loss') train_accuracy = history.item().get('train_accuracy') epochs = list(range(1, len(training_loss) + 1)) for i in range(0, len(train_accuracy)): training_accuracy.append(train_accuracy[i].item() / 100) testing_accuracy = 98.64 #test_accuracy trace0 = go.Scatter(x=epochs, y=training_accuracy, mode="lines", name="Training Accuracy") trace1 = go.Scatter(x=epochs, y=training_loss, mode="lines", name="Training Loss") data = go.Data([trace0, trace1]) layout = go.Layout() fig = go.Figure(data=data, layout=layout) fig['layout']['xaxis'].update(title="Number of Epochs", range=[min(epochs), max(epochs)], dtick=len(epochs) / 10, showline=True, zeroline=True, mirror='ticks', linecolor='#636363', linewidth=2) fig['layout']['yaxis'].update(title="Training Loss and Accuracy", range=[0, 1.05], dtick=0.1, showline=True, zeroline=True, mirror='ticks', linecolor='#636363', linewidth=2) py.image.save_as(fig, filename="Training_Graph.png") print("Training Graph Created") x_axis = ["Training", "Testing"] y_axis = [training_accuracy[-1] * 100, testing_accuracy] trace2 = go.Bar(x=x_axis, y=y_axis, width=[0.3, 0.3]) data = [trace2] layout = go.Layout() fig = go.Figure(data=data, layout=layout) fig['layout']['xaxis'].update(title="Mode", showline=True) fig['layout']['yaxis'].update(title="Accuracy") py.image.save_as(fig, filename="Accuracy_Graph.png") print("Accuracy Graph Created") return
def test_initialize_stream_plot(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot( [Scatter(x=[], y=[], mode="markers", stream=stream)], auto_open=False, world_readable=True, filename="stream-test2", ) self.assertTrue(url.startswith("https://plot.ly/~PythonAPI/")) time.sleep(0.5)
def gen_plotly_url(): # Sign in to plotly if you haven't done so py.sign_in('<YOUR-USERNAME>', '<YOUR-PASSWORD>') # Be careful with this, don't put it on Github!!! # Get current working directory cwd = os.getcwd() # Load config with open(cwd+"/config/config.yml", 'r') as f: config = yaml.load(f, Loader=yaml.FullLoader) # Load test file df = pd.read_csv(cwd+config['data_processed_path'], sep=",") # Load the predictions est_dict = {'date': [df[-1:]['date'].values[0]], 'forecast': [df[-1:]['adj_close'].values[0]]} day = 1 with open(cwd+'/out/est_' + str(date.today()) + '.csv') as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') for row in csv_reader: est_dict['date'].append(str(date.today() + timedelta(days=day))) est_dict['forecast'].append(float(row[0])) day = day + 1 est_df = pd.DataFrame(est_dict) # Plot with plotly miny = min(min(df[-63:]['adj_close']), min(est_df['forecast']))-1 # min y-value of the plot maxy = max(max(df[-63:]['adj_close']), max(est_df['forecast']))+1 # max y-value of the plot fig = go.Figure() fig.add_trace(go.Scatter(x=df[-63:]['date'], y=df[-63:]['adj_close'], mode='lines', name='actual', line=dict(color='blue'))) fig.add_trace(go.Scatter(x=est_df['date'], y=est_df['forecast'], mode='lines', name='predictions', line=dict(color='red'))) fig.add_trace(go.Scatter(x=[str(date.today()), str(date.today())], y=[miny, maxy], mode='lines', line=dict(color='black', dash="dot"), showlegend=False)) fig.update_layout(yaxis=dict(title='USD'), xaxis=dict(title='date')) fig.update_yaxes(range=[miny, maxy]) url=py.plot(fig, filename='est_'+str(date.today()), auto_open=False) return url
def test_stream_multiple_points(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') time.sleep(.5) my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1, 2, 3, 4], y=[2, 1, 2, 5])) time.sleep(.5) my_stream.close()
def test_stream_multiple_points(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') time.sleep(.5) my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1, 2, 3, 4], y=[2, 1, 2, 5])) time.sleep(.5) my_stream.close()
def test_stream_single_points(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) res = py.plot( [Scatter(x=[], y=[], mode="markers", stream=stream)], auto_open=False, world_readable=True, filename="stream-test2", ) time.sleep(0.5) my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1], y=[10])) time.sleep(0.5) my_stream.close()
def test_sign_in_with_config(self): username = '******' api_key = 'place holder' plotly_domain = 'test domain' plotly_streaming_domain = 'test streaming domain' plotly_ssl_verification = False py.sign_in(username, api_key, plotly_domain=plotly_domain, plotly_streaming_domain=plotly_streaming_domain, plotly_ssl_verification=plotly_ssl_verification) config = py.get_config() self.assertEqual(config['plotly_domain'], plotly_domain) self.assertEqual(config['plotly_streaming_domain'], plotly_streaming_domain) self.assertEqual(config['plotly_ssl_verification'], plotly_ssl_verification)
def test_stream_layout(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') time.sleep(.5) title_0 = "some title i picked first" title_1 = "this other title i picked second" my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_0)) time.sleep(.5) my_stream.close() my_stream.open() my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_1)) my_stream.close()
def test_stream_layout(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) url = py.plot([Scatter(x=[], y=[], mode='markers', stream=stream)], auto_open=False, world_readable=True, filename='stream-test') time.sleep(.5) title_0 = "some title i picked first" title_1 = "this other title i picked second" my_stream = py.Stream(tk) my_stream.open() my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_0)) time.sleep(.5) my_stream.close() my_stream.open() my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_1)) my_stream.close()
def test_stream_no_scheme(self): # If no scheme is used in the plotly_streaming_domain, port 80 # should be used for streaming and ssl_enabled should be False py.sign_in(un, ak, **{'plotly_streaming_domain': 'stream.plot.ly'}) my_stream = py.Stream(tk) expected_streaming_specs = { 'server': 'stream.plot.ly', 'port': 80, 'ssl_enabled': False, 'ssl_verification_enabled': False, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk } } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
def test_stream_no_scheme(self): # If no scheme is used in the plotly_streaming_domain, port 80 # should be used for streaming and ssl_enabled should be False py.sign_in(un, ak, **{"plotly_streaming_domain": "stream.plot.ly"}) my_stream = py.Stream(tk) expected_streaming_specs = { "server": "stream.plot.ly", "port": 80, "ssl_enabled": False, "ssl_verification_enabled": False, "headers": { "Host": "stream.plot.ly", "plotly-streamtoken": tk }, } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
def plot_data_by_state(): us_states = pd.read_csv("us_state_list.csv") us_state_list = us_states['Abbreviation'] state_numbers = [] for state in us_state_list: filters = { "state": [state], "site_year": { "min": 2014.0, "max": 2014.08333 } } eui_dict = histogram(group_by=["electric_eui"], filters=filters) num_buildings = eui_dict['totals']['number_of_matching_buildings'] state_numbers.append(num_buildings) us_states['Count'] = state_numbers data = [ dict(type='choropleth', autocolorscale=False, locations=us_states['Abbreviation'], z=us_states['Count'].astype(float), locationmode='USA-states', marker=dict(line=dict(color='rgb(255,255,255)', width=2)), colorbar=dict(title="Millions USD")) ] layout = dict( title='Number of buildings in the BPD database by state', geo=dict( scope='usa', projection=dict(type='albers usa'), showlakes=True, lakecolor='rgb(255, 255, 255)', ), ) fig = dict(data=data, layout=layout) py.sign_in('Anna8128', '46zTykSNwaQwgnc6LM7Y') py.plot(fig)
def test_stream_no_scheme(self): # If no scheme is used in the plotly_streaming_domain, port 80 # should be used for streaming and ssl_enabled should be False py.sign_in(un, ak, **{'plotly_streaming_domain': 'stream.plot.ly'}) my_stream = py.Stream(tk) expected_streaming_specs = { 'server': 'stream.plot.ly', 'port': 80, 'ssl_enabled': False, 'ssl_verification_enabled': False, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk } } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
def test_sign_in_with_config(self): username = "******" api_key = "place holder" plotly_domain = "test domain" plotly_streaming_domain = "test streaming domain" plotly_ssl_verification = False py.sign_in( username, api_key, plotly_domain=plotly_domain, plotly_streaming_domain=plotly_streaming_domain, plotly_ssl_verification=plotly_ssl_verification, ) config = py.get_config() self.assertEqual(config["plotly_domain"], plotly_domain) self.assertEqual(config["plotly_streaming_domain"], plotly_streaming_domain) self.assertEqual(config["plotly_ssl_verification"], plotly_ssl_verification)
def create_country_map(self): df_countries = pd.read_csv('country_codes_iso_3.csv') fig = go.Figure(data=go.Choropleth( locations=df_countries['code'], z=self.data_frame['k-means'], colorscale='rainbow', autocolorscale=False, reversescale=True, marker_line_color='darkgray', marker_line_width=0.5, colorbar_title='K-Means', )) fig.update_layout(title_text='K Means Clustering', geo=dict(showframe=False, showcoastlines=False, projection_type='equirectangular')) py.sign_in('euguman', '3Zb8TzOCWAs0JmBmNERB') py.image.save_as(fig, filename='country_map.png')
def get_graphs(self, k_means): """ Build scatter and choropleth graph from the predictions made by the KMeans model """ # First graph prep fig, ax = plt.subplots() sc = ax.scatter(self.proc_data['Social support'].values, self.proc_data['Generosity'].values, c=k_means.labels_.astype(np.float), edgecolor='k') fig.colorbar(sc, ax=ax) ax.set_xlabel('Social support', fontsize=12) ax.set_ylabel('Generosity', fontsize=12) fig.suptitle('K-Means clustering: Generosity - Social support', fontsize=12, fontweight='bold') dir_path = self.path[:self.path.rfind('/')] first_path = dir_path + '/Graph1.png' plt.savefig(first_path) plt.close(fig) # Second graph prep countries_data = pd.read_csv('countries_codes.csv') countries_dict = dict([ (country, code) for country, code in zip(countries_data['Country'].to_numpy(), countries_data['Alpha-3code'].to_numpy()) ]) self.proc_data['country id'] = \ [countries_dict[x] if x in countries_dict else x for x in self.proc_data['country'].values] choro_map = plex.choropleth( self.proc_data, locations="country id", color="cluster", color_continuous_scale=plex.colors.sequential.Aggrnyl, title='K-Means clustering by countries') pltly.sign_in('sfreiman', 'tQTEO9EOznyYp5HEu5Or') second_path = dir_path + '/Graph2.png' pltly.image.save_as(choro_map, filename=second_path) return first_path, second_path
def __init__(self, key='', username='', plotUrl='', sharing=['public', 'private', 'secret'], fileopt=['new', 'overwrite', 'extend', 'append']): ''' Constructor. fn (string) -- the name that will be associated with this figure fileopt ('new' | 'overwrite' | 'extend' | 'append') -- 'new' creates a 'new': create a new, unique url for this plot 'overwrite': overwrite the file associated with `filename` with this 'extend': add additional numbers (data) to existing traces 'append': add additional traces to existing data lists world_readable (default=True) -- make this figure private/public auto_open (default=True) -- Toggle browser options True: open this plot in a new browser tab False: do not open plot in the browser, but do return the unique url sharing ('public' | 'private' | 'sharing') -- Toggle who can view this graph - 'public': Anyone can view this graph. It will appear in your profile and can appear in search engines. You do not need to be logged in to Plotly to view this chart. - 'private': Only you can view this plot. It will not appear in the Plotly feed, your profile, or search engines. You must be logged in to Plotly to view this graph. You can privately share this graph with other Plotly users in your online Plotly account and they will need to be logged in to view this plot. - 'secret': Anyone with this secret link can view this chart. It will not appear in the Plotly feed, your profile, or search engines. If it is embedded inside a webpage or an IPython notebook, anybody who is viewing that page will be able to view the graph. You do not need to be logged in to view this plot. ''' DomainBehavior.__init__(self) if key != '' and username != '': py.sign_in(username, key) self.plotUrl = '' self.state = {'status': 'IDLE', 'sigma': INFINITY}
def draw_map(self): self.create_codes() fig = go.Figure(data=go.Choropleth( locations=self.dataset['CODE'], z=self.dataset['Cluster'], text=self.dataset['country'], colorscale='Blues', autocolorscale=False, reversescale=True, marker_line_color='darkgray', marker_line_width=0.5, colorbar_title='Countries Clusters', )) fig.update_layout( title_text='Countries Clusters', geo=dict(showframe=False, showcoastlines=False, projection_type='equirectangular'), ) py.sign_in("nivgold", "CmHRBPCSQCYksweD8KNu") py.image.save_as(fig, filename='Countries Clusters.png')
def test_sign_in_with_config(self): username = '******' api_key = 'place holder' plotly_domain = 'test domain' plotly_streaming_domain = 'test streaming domain' plotly_ssl_verification = False py.sign_in( username, api_key, plotly_domain=plotly_domain, plotly_streaming_domain=plotly_streaming_domain, plotly_ssl_verification=plotly_ssl_verification ) config = py.get_config() self.assertEqual(config['plotly_domain'], plotly_domain) self.assertEqual( config['plotly_streaming_domain'], plotly_streaming_domain ) self.assertEqual( config['plotly_ssl_verification'], plotly_ssl_verification )
def cluster(self): if (self.wrongInput is True): mb.showerror("K Means Clustering", "wrong input") else: try: model = clustering.clustering.kmeans(self, self.df, self.ClustersBox.get(), self.runsBox.get()) fig = plt.figure(figsize=(4, 4)) plt.scatter(model['Social support'], model['Generosity'], c=model['clusters'], cmap='jet') plt.title('Generosity as a function of social support') plt.xlabel('social support') plt.ylabel('generosity') canvas = FigureCanvasTkAgg(fig, master=root) canvas.draw() canvas.get_tk_widget().grid(row=6, column=1, ipadx=20, ipady=20) newDF = self.addCodeCountries(model) fig = px.choropleth( newDF, locations="CODE", color="clusters", hover_name="COUNTRY", color_continuous_scale=px.colors.sequential.Plasma) py.sign_in('chenshor', 'vK4Ro730ZZHKIVCzFSBH') py.image.save_as(fig, filename='country.png') self.showImage() MsgBox = mb.askokcancel("K Means Clustering", "clustering completed successfully!") except ValueError: self.wrongInput = True
def test_stream_https(self): # If the https scheme is used in the plotly_streaming_domain, port 443 # should be used for streaming, ssl_enabled should be True, # and ssl_verification_enabled should equal plotly_ssl_verification ssl_stream_config = { 'plotly_streaming_domain': 'https://stream.plot.ly', 'plotly_ssl_verification': True } py.sign_in(un, ak, **ssl_stream_config) my_stream = py.Stream(tk) expected_streaming_specs = { 'server': 'stream.plot.ly', 'port': 443, 'ssl_enabled': True, 'ssl_verification_enabled': True, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk } } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
def test_stream_https(self): # If the https scheme is used in the plotly_streaming_domain, port 443 # should be used for streaming, ssl_enabled should be True, # and ssl_verification_enabled should equal plotly_ssl_verification ssl_stream_config = { 'plotly_streaming_domain': 'https://stream.plot.ly', 'plotly_ssl_verification': True } py.sign_in(un, ak, **ssl_stream_config) my_stream = py.Stream(tk) expected_streaming_specs = { 'server': 'stream.plot.ly', 'port': 443, 'ssl_enabled': True, 'ssl_verification_enabled': True, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk } } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
def test_stream_https(self): # If the https scheme is used in the plotly_streaming_domain, port 443 # should be used for streaming, ssl_enabled should be True, # and ssl_verification_enabled should equal plotly_ssl_verification ssl_stream_config = { "plotly_streaming_domain": "https://stream.plot.ly", "plotly_ssl_verification": True, } py.sign_in(un, ak, **ssl_stream_config) my_stream = py.Stream(tk) expected_streaming_specs = { "server": "stream.plot.ly", "port": 443, "ssl_enabled": True, "ssl_verification_enabled": True, "headers": { "Host": "stream.plot.ly", "plotly-streamtoken": tk }, } actual_streaming_specs = my_stream.get_streaming_specs() self.assertEqual(expected_streaming_specs, actual_streaming_specs)
# import plotly.express as px import pandas as pd import chart_studio import chart_studio.tools as tls import plotly.graph_objs as go import chart_studio.plotly as py import os, sys import matplotlib import base64 from matplotlib import cm import math from matplotlib import pyplot as plt import numpy as np from matplotlib.patches import Circle, Wedge, Rectangle # py.sign_in('nikhile' ,'OkrregXQ8kgWtuZEcuOI') py.sign_in('aditya2019', 'O1AXV3C7JqJm5D2egggr') # In[ ]: # Establishing connection with MongoDB with specified database app = Flask(__name__) CORS(app) app.config[ 'MONGO_URI'] = "mongodb+srv://headstrait_1:[email protected]/stockbazaar?retryWrites=true&w=majority" mongo = PyMongo(app) # Specifying the collection name collection = mongo.db.stocks_data_2 # Plotting OHLC graph for indices @app.route("/ohlcindices/<ticker_id>", methods=["GET"])
def plotly_setup(): user = os.environ['plotly_user'] key = os.environ['plotly_key'] py.sign_in(username=user, api_key=key) set_config_file(plotly_domain="https://plotly.com", plotly_api_domain="https://api.plotly.com")
import streamlit as st import pandas as pd import plotly.express as px from datetime import date from datetime import timedelta import plotly import chart_studio.plotly as py import numpy as np py.sign_in('nishtha697', 'RgHrQxWQq9hp2PQofsUg') import plotly.graph_objs as go @st.cache(ttl=60 * 5, max_entries=20) def load_state_daily(): state_daily = pd.read_csv( "https://api.covid19india.org/csv/latest/state_wise.csv") return state_daily state_daily = load_state_daily() @st.cache(ttl=60 * 5, max_entries=20) def load_district_data(): district_data = pd.read_csv( "https://api.covid19india.org/csv/latest/district_wise.csv") return district_data district_data = load_district_data()
import chart_studio.plotly as py #import plotly.graph_objs from plotly.graph_objs import * py.sign_in('Happy_Das', 'v3MozO2Qhlwcpd95upsf') samples = [100, 500, 1000, 1500, 2000, 2500, 3000, 4000, 5000, 8000] xi1_error = [ 0.0183079, 0.00288071, 0.00280302, 0.00082023, 0.00019435, 0.00061994, 0.00011266, 0.00065684, 0.00033986, 0.00008628 ] xi2_error = [ 0.1892245, 0.12299614, 0.03353519, 0.04834064, 0.02900468, 0.02863002, 0.04124718, 0.01890743, 0.01965981, 0.02786769 ] def visualize(sample, averagexi1, averagexi2): samp, avg_xi1, avg_xi2 = [], [], [] for a, b, c in zip(sample, averagexi1, averagexi2): samp.append(a) avg_xi1.append(b) avg_xi2.append(c) data1 = { "x": samp, "y": avg_xi1, "name": "$\\hat\\xi_{1e}$ ", "type": "scatter" } data2 = { "x": samp,
import chart_studio.plotly as py import pandas as pd import plotly.express as px import plotly.graph_objects as go from numpy.ma import var py.sign_in("Muffles", "n7fnqiXZVX9eIO8YVhOq") customer_list = [] useful_customer = [] fileName = None unique_states = [] state_count = [] moneylist = [] def reset(): customer_list.clear() useful_customer.clear() unique_states.clear() state_count.clear() moneylist.clear() def get_map(): df = pd.read_csv("State_List.csv") for col in df.columns: df[col] = df[col].astype(str) scl = [[0.0, 'rgb(255, 255, 255)'], [1.0, 'rgb(255, 0, 0)']]
def setUp(self): super(MetaTest, self).setUp() py.sign_in('PythonTest', 'xnyU0DEwvAQQCwHVseIL')
mode='lines', name=model_name)) print( 'Now plot--------------------------------------------------------------' ) # Edit the layout layout = dict( title='Testing Accuracy across Models for various {0} Filtering'.format( name), xaxis=dict(title='Feature Count'), yaxis=dict(title='Testing Accuracy (%)'), ) fig = dict(data=data_graph, layout=layout) #use plotly online py.sign_in('Avi-141', '0vBYQs5NNzyATMxW5m0P') py.iplot(fig, filename='line-mode') # done #get report of 4k pages #repeat the exp. with individual csv of serc labels #. Mohit 150, # done #calculate gcs for new pages >> in progress #calculate similarity score >> # input security group URLs # WIKI-SEED URL, C3 in progress
def setUp(self): super(FolderAPITestCase, self).setUp() py.sign_in('PythonTest', 'xnyU0DEwvAQQCwHVseIL')
def test_sign_in_cannot_validate(self): self.users_current_mock.side_effect = exceptions.PlotlyRequestError( 'msg', 400, 'foobar' ) with self.assertRaisesRegexp(_plotly_utils.exceptions.PlotlyError, 'Sign in failed'): py.sign_in('foo', 'bar')
def setUp(self): super(TestStreaming, self).setUp() py.sign_in(un, ak, **config)