def PredictTemperatureWithTwoVariale(firstColumn, secondColumn):
# Fetch data from the realtime database as a matrix object
df = lib.FetchData(firstColumn, secondColumn)
# Get the column named temperature to a list
dt_firstList = df[firstColumn].tolist()
dt_secondList = df[secondColumn].tolist()
# Convert each value in that list to float type
dt_firstList = [float(i) for i in dt_firstList]
dt_secondList = [float(i) for i in dt_secondList]
# Calulate the right value for 80% data we need to train
size_tran = int((len(df) * 0.8))
# Create a dataframe object
df_model = pd.DataFrame()
# Create a column's named x with values fetch from 0th to 80% of first column data
df_model['x'] = dt_firstList[:size_tran - 1]
# Create a column's named y with values fetch from 1th to 80% of first column data
df_model['y'] = dt_firstList[1:size_tran]
# Create a column's named z with values fetch from 0th to 80% of second column data
df_model['z'] = dt_secondList[:size_tran - 1]
X = df_model.drop('y', axis=1)
Y = df_model['y']
lm = LinearRegression()
lm.fit(X, Y)
a, b = lm.coef_
c = lm.intercept_
# Frint out the new model which is in matrix type
# print(df_model)
print(a)
print(b)
print(c)
return (dt_firstList, dt_secondList, size_tran, a, b, c)
def PredictTemperatureWithOneVariale(firstColumn):
# Fetch data from the realtime database as a matrix object
df = lib.FetchData(firstColumn, None)
# Get the column named temperature to a list
dt_list = df[firstColumn].tolist()
#df_Humid = df[columnx].tolist()
# Convert each value in that list to float type
dt_list = [float(i) for i in dt_list]
#dt_listx = [float(i) for i in df_Humid]
# Calulate the right value for 80% data we need to train
size_tran = int((len(df) * 0.8))
# Create a dataframe object
df_model = pd.DataFrame()
# Create a column's named x with values fetch from 0th to 80% of data th
df_model['x'] = dt_list[:size_tran - 1]
# Create a column's named x with values fetch from 1th to 80% of data th
df_model['y'] = dt_list[1:size_tran]
# Frint out the new model which is in matrix type
# print(df_model)
# Calculating a,b parameters through Linear Regression. The outputs are a and b params
slope, intercept, r, p, std_err = stats.linregress(df_model['x'],
df_model['y'])
# That is a param
print(slope)
# That is b param
print(intercept)
# That is error % value
print(std_err)
return (dt_list, size_tran, slope, intercept, std_err)
def getNextOneVariableAuto():
currentTemperature = myFetch.FetchLastDataFromRealtimeDB(
"temperature", None)
dt_list, size_tran, slope, intercept, std_err = myCal.PredictTemperatureWithOneVariale(
"temperature")
return jsonify({
'Current_Temperature':
currentTemperature,
'Next_Temperature':
myCal.fx(currentTemperature, slope, intercept)
})
def getNextTwoVariableAuto():
currentTemperature, currentHumidity = myFetch.FetchLastDataFromRealtimeDB(
"temperature", "humidity")
dt_firstList, dt_secondList, size_tran, a, b, c = myCal.PredictTemperatureWithTwoVariale(
"temperature", "humidity")
return jsonify({
"Current_Temperature":
currentTemperature,
"Current_Humidity":
currentHumidity,
'Next_Temperature':
myCal.f(currentTemperature, currentHumidity, a, b, c)
})
def __init__(self):
dataFetcher = FetchData()
self.dataFetcher = dataFetcher
print("Loading data...")
self.running_plan = self.dataFetcher.get_running_plan()
self.weather_data = self.dataFetcher.get_weather_forecast()
# Filter for whole park only
self.weather_data = self.weather_data[
self.weather_data['windpark_zone'] == 'WP']
self.turbines = set(self.running_plan.turbine.values)
self.net = get_trained_net()
self.date_format = "%Y-%m-%d %H:%M:%S%z"
import FetchData as fetch
inputPath = r'C:\Users\CNOC-DC\Downloads\Sections to be Taken Over.xlsx'
outputPath = r'C:\Users\CNOC-DC\Downloads\Stations to be Taken Over.xlsx'
if __name__ == '__main__':
fetch.fetch(inputPath, outputPath)
print("Phoenix Suns:")
elif teams == 'kings':
print("Sacramento Kings:")
elif teams == 'raptors':
print("Toronto Raptors:")
elif teams == 'jazz':
print("Utah Jazz")
elif teams == 'wizards':
print("Washington Wizards:")
print()
teams = [teams]
# initializing data frame
plyrDataFrame = pd.DataFrame()
# running nbaTeamStats func & iterating through teams
for i in teams:
plyrDataFrame = plyrDataFrame.append(fd.nbaTeamStats(i, year))
# writing .csv for external analysis
plyrDataFrame.to_csv("NBA_Player_Stats.csv")
# printing df for quick n' dirty view of pulled data
print(plyrDataFrame)
print()
rerun = input("Run Again?(Y/N): ")
rerun = rerun.lower()
if rerun == 'y':
loop = 1
elif rerun == 'n':
loop = 0
def result():
re=FetchData.data()
return render_template("result.html",tables= [re.to_html()])
def __init__(self, cal_dir, cal_name, data_dir, data_name, query_dir, query_name, save_dir, save_name, \
x_span, y_span, lim_mag, ours=True):
# Form the query
if ours == True:
fdata.sData2Query(data_dir, data_name, query_dir, query_name)
else:
fdata.sFinder2Query(data_dir, data_name, query_dir, query_name)
# Load the query
self.object_dict = rquer.readQuery(query_dir, query_name)
# Init parameters
self.save_dir = save_dir
self.save_name = save_name
self.x_span = x_span
self.y_span = y_span
self.lim_mag = lim_mag
# Find the plot limits
self.ra_min, self.ra_max, self.dec_min, self.dec_max = findPlotBorders(self.object_dict)
# Load the catalog
self.star_catalog = rcal.loadGaiaCatalog(cal_dir, cal_name, lim_mag=self.lim_mag, ra_min=self.ra_min, \
ra_max=self.ra_max, dec_min=self.dec_min, dec_max=self.dec_max)
# Construct color array
color_arr = cm.nipy_spectral(np.linspace(0.2, 1, len(self.object_dict)))
color_order = random.sample(range(len(color_arr)), len(color_arr))
self.color_arr = color_arr[color_order]
# Init plot
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
# Plot stars
self.ax.scatter(self.star_catalog[:, 0], self.star_catalog[:, 1], \
s=(2.512**(-self.star_catalog[:, 2])*1500), color='black')
# Plot asteroids
for i, object_i in enumerate(self.object_dict):
# Extract coordinates and data
date_str_arr, ra_arr, dec_arr, pa_arr = self.object_dict[object_i]
color = self.color_arr[i]
for i, date_str, ra, dec in zip(range(len(date_str_arr)), date_str_arr, ra_arr, dec_arr):
# Scatter plot, label only if this is the first object in the series
if i == 0:
self.ax.scatter(ra, dec, c=color, marker='x', label=object_i)
elif i == 2:
self.ax.scatter(ra, dec, c=color, marker='x')
pa = np.deg2rad(pa_arr[i + 1])
r = np.sqrt((ra - ra_arr[i+1])**2 + (dec-dec_arr[i+1])**2)
self.ax.arrow(ra, dec, r*np.sin(pa), r*np.cos(pa), width=0.01)
print(object_i, r, pa)
elif i == 1:
self.ax.scatter(ra, dec, c=color, marker='x')
if i != 3:
self.ax.annotate(date_str, (ra, dec), xycoords='data', color='r')
# Label axes
self.ax.set_xlabel('RA [deg]')
self.ax.set_ylabel('Dec [deg]')
# Legend
self.legend = self.ax.legend(loc='upper right', fontsize='x-small')
# Save plot limits
self.x_min, self.x_max = self.ax.get_xlim()
self.y_min, self.y_max = self.ax.get_ylim()
# Plot center
self.x_center = (self.x_min + self.x_max) / 2
self.y_center = (self.y_min + self.y_max) / 2
# Offsets between the rectangle center and lower left corner
self.x_off = self.x_span/2
self.y_off = self.y_span/2
# Init FOV rectangle
self.fov_rect = Rectangle((self.x_center - self.x_off, self.y_center - self.y_off), self.x_span, self.y_span, \
fill=True, alpha=0.5, facecolor='blue', edgecolor='black', linewidth=1)
# Coordinates to which the FOV rectangle is moved
self.new_x = None
self.new_y = None
# Where the selected rectangle positions and names are saved
self.name_arr = []
self.x_arr = []
self.y_arr = []
# Plotted uncertainties
self.uncertainties_arr = None
self.ax.add_patch(self.fov_rect)
# Register mouse/keyboard events
self.ax.figure.canvas.mpl_connect('motion_notify_event', self.onMouseMotion)
self.ax.figure.canvas.mpl_connect('button_press_event', self.onMousePress)
self.ax.figure.canvas.mpl_connect('key_press_event', self.onKeyPress)
# Set tight layout
self.fig.tight_layout()
self.ax.margins(0)
self.ax.set_aspect('equal')
self.ax.figure.canvas.draw()
def onKeyPress(self, event):
""" Evokes when a key is pressed. """
key = event.key
# Show uncertainties
if (key == 'u') or (key == 'U'):
# Go through all objects
for i, object_i in enumerate(self.object_dict):
# Get all uncertainties
uncertainties_arr = fdata.getUncertainties(object_i)
val_arr = self.object_dict[object_i]
ra_arr, dec_arr = val_arr[1], val_arr[2]
# Get current RA and Dec
if len(ra_arr) and len(dec_arr):
ra_curr, dec_curr = ra_arr[0], dec_arr[0]
# Convert uncertainties to float
ra_uncertainties = uncertainties_arr[:, 0].astype('float')
dec_uncertainties = uncertainties_arr[:, 1].astype('float')
sign_arr = uncertainties_arr[:, 2]
# Form colors array
color_rgb_arr = []
for sign in sign_arr:
# Get object color
color = self.color_arr[i]
# Form lighter and darker color
rgb_darker_color = col.to_rgb(color)
rgb_lighter_color = list([c + 0.1 for c in rgb_darker_color])
if sign == '!':
color_rgb_arr.append(rgb_darker_color)
elif sign == '!':
color_rgb_arr.append(rgb_lighter_color)
# Add uncertainties to center to get coordinates
ra_coords = ra_uncertainties + ra_curr
dec_coords = dec_uncertainties + dec_curr
# Update plot limits
self.ax.set_xlim(min(ra_coords), max(ra_coords))
self.ax.set_ylim(min(dec_coords), max(dec_coords))
self.ax.set_aspect('equal')
# Plot uncertainties
uncertainties_i = self.ax.scatter(ra_coords, dec_coords, color=color_rgb_arr, marker='o', s=1)
self.uncertainties_arr.append(uncertainties_i)
# Hide uncertainties
if (key == 'h') or (key == 'H'):
if self.uncertainties_arr is not None:
for artist in self.uncertainties_arr:
artist.remove()
# Update plot
self.ax.figure.canvas.draw()
def send_algo():
x = request.get_json()
entry_algo = x['entry_algo']
exit_algo = x['exit_algo']
stop_loss = x['stop_loss']
take_profit = x['take_profit']
quantity = x['quantity']
start_cash = x['start_cash']
start_year = x['start_year']
start_month = x['start_month']
start_day = x['start_day']
end_year = x['end_year']
end_month = x['end_month']
end_day = x['end_day']
start_time = x['start_time']
end_time = x['end_time']
broker_commission = x['broker_commission']
company_name = x['stock_name'].replace(" ", "").split(",")
output_data = []
for name in company_name:
temp1 = entry_algo + exit_algo + stop_loss + take_profit + quantity + start_cash + start_year + start_month + start_day + end_year + end_month + end_day + "0"
temp2 = entry_algo + exit_algo + stop_loss + take_profit + quantity + start_cash + start_year + start_month + start_day + end_year + end_month + end_day + broker_commission
temp3 = start_year + start_month + start_day + end_year + end_month + end_year
file_name_without_brokerage = name + (hashlib.md5(
temp1.encode())).hexdigest()
file_name_with_brokerage = name + (hashlib.md5(
temp2.encode())).hexdigest()
data_file_name = name + (hashlib.md5(temp3.encode())).hexdigest()
file_name = [file_name_without_brokerage, file_name_with_brokerage]
broker_type = [0, float(broker_commission)]
i = 0
for i in range(0, 2):
output = []
if (path.exists("./Outputs/" + file_name[i] + '.json')):
if (broker_type[i] == 0):
with open("./Outputs/" + file_name[i] + '.json', 'r') as f:
output.append(json.load(f))
f.close()
output_data.append({
"company_name": name,
"Type": "Without Brokerage",
"Output": output[0]
})
else:
with open("./Outputs/" + file_name[i] + '.json', 'r') as f:
output.append(json.load(f))
f.close()
output_data.append({
"company_name": name,
"Type": "With Brokerage",
"Output": output[0]
})
else:
if (broker_type[i] == 0):
open("./Outputs/" + file_name[i] + '.json', 'w').close()
fd.compute(entry_algo, exit_algo, stop_loss, take_profit,
quantity, start_cash, start_year, start_month,
start_day, end_year, end_month,
end_day, start_time, end_time,
str(broker_type[i]), name, file_name[i],
data_file_name)
os.system("python3 ./Scripts/" + file_name[i] + ".py")
with open("./Outputs/" + file_name[i] + '.json', 'r') as f:
output.append(json.load(f))
f.close()
output_data.append({
"company_name": name,
"Type": "Without Brokerage",
"Output": output[0]
})
else:
open("./Outputs/" + file_name[i] + '.json', 'w').close()
fd.compute(entry_algo, exit_algo, stop_loss, take_profit,
quantity, start_cash, start_year, start_month,
start_day, end_year, end_month,
end_day, start_time, end_time,
str(broker_type[i]), name, file_name[i],
data_file_name)
os.system("python3 ./Scripts/" + file_name[i] + ".py")
with open("./Outputs/" + file_name[i] + '.json', 'r') as f:
output.append(json.load(f))
f.close()
output_data.append({
"company_name": name,
"Type": "With Brokerage",
"Output": output[0]
})
return json.dumps({
'success': True,
'data': output_data
}), 200, {
'Content-Type': 'application/json'
}
def getCurrentTemperature():
currentTemp = myFetch.FetchLastDataFromRealtimeDB("temperature", None)
return jsonify({'Current_Temperature': currentTemp})
def dashboard():
al,a_d,cu,c_d,ir,i_d,ni,ni_d,d_c,d_a,d_i,d_n,val_c,d_c_lis,val_a,d_a_lis,val_i,d_i_lis,val_n,d_n_lis=rate.curr_rate()
al_f=feed.news_feed("aluminium")
cu_f = feed.news_feed("copper")
ir_f = feed.news_feed("iron")
ni_f = feed.news_feed("gold")
inr=cd.indian_rs()
return render_template('dashb.html',al=al,cu=cu,ir=ir,ni=ni,a_d=a_d,c_d=c_d,i_d=i_d,ni_d=ni_d,al_f=al_f,cu_f=cu_f,ir_f=ir_f,ni_f=ni_f,d_c=d_c,
d_a=d_a,d_i=d_i,d_n=d_n,val_c=val_c,d_c_lis=d_c_lis,val_a=val_a,d_a_lis=d_a_lis,val_i=val_i,d_i_lis=d_i_lis,val_n=val_n,
d_n_lis=d_n_lis,inr=inr)