def home():
form = MainForm()
if request.method == 'POST':
if form.validate_on_submit():
if not verify(form.url_field.data):
flash('Please enter a valid YouTube URL', 'danger')
format_display = dict(FormatChoices).get(form.output_format.data)
if format_display == 'Video':
result = downloadVideo(form.url_field.data)
print(result)
if result == "-1" or result == "-2":
flash('An unexpected error has occured. Please try again',
'danger')
else:
flash('File successfully converted', 'success')
form.url_field.data = ""
return redirect('/downloadfile/' + result)
elif format_display == "Audio":
result = downloadAudio(form.url_field.data)
if result == "-1" or result == "-2":
flash('An unexpected error has occured. Please try again',
'danger')
else:
flash('File successfully converted', 'success')
return redirect('/downloadfile/' + result)
return render_template('index.html', form=form)
def __init__(self):
self.main_form = MainForm()
self.grid_form = GridForm()
self.ellipsoids_ini = self.__parse_ellipsoids()
self.ellipsoid = None
self.sphere_projection_type = None
self.sphere_projections_list = None
self.__init_ui()
def index(request):
if request.method == "POST":
form = MainForm(request.POST, request.FILES)
if form.is_valid():
return createCSV(request.FILES["result_ranks"], request.FILES["website_list"])
else:
form = MainForm()
return render(request, "index.html", {"form": form})
def index():
if 'username' in session:
mform_2 = MainForm()
if mform_2.validate_on_submit() :
return render_template('main.html', mform = mform_2, username = session['username'], search = search_games(mform_2))
return render_template('main.html', mform = mform_2, username = session['username'], search=get_all())
return render_template('index.html')
def post(self, request):
form = MainForm(request.POST)
if not form.is_valid():
context = {'form': MainForm(), 'risk_score': None}
return render(request, self.template_name, context)
address = request.POST['destination_address']
risk_score = get_address_risk_score(address)
context = {'form': form, 'risk_score': risk_score}
return render(request, self.template_name, context)
def index():
form = MainForm()
if form.validate_on_submit():
c_i = form.number_of_cities.data
c_o = form.number_of_colors.data
n_r = form.number_of_relations.data
t_r = form.relations.data
results = process_the_info(c_i, c_o, n_r, t_r)
return redirect(url_for('result', results=results))
return render_template('index.html', form=form)
def main():
"""Main page."""
form = MainForm()
if request.method == 'POST':
if not form.validate():
return render_template('main.html', form=form)
else:
link = match_texts(form.text_1.data, form.text_2.data)
return redirect('results/' + link)
elif request.method == 'GET':
return render_template('main.html', form=form)
def hello_world():
today = datetime.now().strftime('%A %d %b %Y')
global dollarRates
form = MainForm()
if form.validate_on_submit():
if form.firstCurr.data == form.secondCurr.data:
return redirect('/')
else:
uri = '/search?in=' + form.firstCurr.data + '&out=' + form.secondCurr.data
return redirect(uri)
return render_template('main.html', form=form, dollarRates=dollarRates, today=today)
def main():
"""Main page."""
form = MainForm()
if request.method == 'POST':
if not form.validate():
return render_template('main.html', form=form)
else:
link = match_texts(form.text_1.data, form.text_2.data)
return redirect('results/' + link)
elif request.method == 'GET':
return render_template('main.html', form=form)
def api_root():
if username == 'unknown':
return redirect('/login')
form = MainForm()
if form.validate_on_submit():
for device in form.devices.data:
device_params = form.get_device(device)
if icomera.reboot(device_params['ip'], form.configure.data):
flash('Перезагружаю ' + device_params['name'], category='ok')
else:
flash('Не могу подключиться к ' + device_params['name'], category='error')
return render_template('index.html', title = username, username = fullname, form = form)
def index(request):
if request.method == 'POST':
form = MainForm(request.POST, request.FILES)
if form.is_valid():
return createCSV(request.FILES['result_ranks'],
request.FILES['website_list'])
else:
form = MainForm()
return render(request, 'index.html', {
'form': form,
})
def upload_from_partners(request):
vals = None
if request.method == 'POST':
form = MainForm(request.POST, request.FILES)
if form.is_valid():
vals = createCSV(request.FILES['partner_csv'])
else:
form = MainForm()
return render(request, 'upload_from_partners.html', {
'form': form, 'vals': vals
})
def display_prices_history(coin_symbol):
form = MainForm()
if request.method == 'POST':
if form.validate_on_submit():
name = request.form['crypto_name']
return redirect('/prices/history/monthly/' + name)
data = get_prices_history_monthly(coin_symbol)
return render_template('coins/history.html',
values_usd=data['values_usd'],
values_eur=data['values_eur'],
labels=data['labels'],
symbol=coin_symbol)
def upload_from_partners(request):
vals = None
if request.method == 'POST':
form = MainForm(request.POST, request.FILES)
if form.is_valid():
vals = createCSV(request.FILES['partner_csv'])
else:
form = MainForm()
return render(request, 'upload_from_partners.html', {
'form': form,
'vals': vals
})
def api_root():
if username == 'unknown':
return redirect('/login')
form = MainForm()
if form.validate_on_submit():
for device in form.devices.data:
device_params = form.get_device(device)
if icomera.reboot(device_params['ip'], form.configure.data):
flash('Перезагружаю ' + device_params['name'], category='ok')
else:
flash('Не могу подключиться к ' + device_params['name'],
category='error')
return render_template('index.html',
title=username,
username=fullname,
form=form)
def main():
main_form = MainForm()
message = None
# post method for main form to work with spotify API
if main_form.validate_on_submit():
search_name = main_form.search_name.data
first_query = spotify.search('artist', search_name,
session.get('auth_header'))
if (len(first_query[spotify.SPOTIFY_ARTISTS][spotify.SPOTIFY_ITEMS]) ==
0):
return redirect(url_for('bad_query'))
artist_id = first_query[spotify.SPOTIFY_ARTISTS][
spotify.SPOTIFY_ITEMS][0][spotify.SPOTIFY_ID]
# getting related artists for a specific artist
second_query = spotify.get_related_artists(artist_id,
session.get('auth_header'))
rel_artists = []
for artist in second_query[spotify.SPOTIFY_ARTISTS]:
rel_artists.append(artist['name'])
if len(rel_artists) > 10:
rel_artists = rel_artists[:10]
# getting top tracks for a specific artist
third_query = spotify.get_artists_top_tracks(
artist_id, session.get('auth_header'))
top_tracks = []
for track in third_query[spotify.SPOTIFY_TRACKS]:
top_tracks.append(track['name'])
if len(top_tracks) > 10:
top_tracks = top_tracks[:10]
db.db.artist.insert({
"name": search_name,
"related_artists": rel_artists,
"top_tracks": top_tracks
})
return redirect(url_for('user'))
return render_template('main.html', main_form=main_form)
def main_view(request):
if request.method == "POST":
form = MainForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
enc_message = form.cleaned_data['enc_message']
## SAVING DATA TO DB
user = User(name=name, email=email, message=message, enc_message=enc_message)
user.save()
return redirect('success/')
else:
form = MainForm()
return render(request, 'index.html', {'form': form})
def index():
form = MainForm()
if request.method == 'POST' and form.validate_on_submit():
db = get_db()
posts = db.posts
post = {
"rectype": str(form.rectype.data),
"book_title": str(form.book_title.data),
"book_author": str(form.book_author.data),
"bevtype": str(form.bevtype.data),
"bevtype_other": str(form.bevtype_other.data),
"time": asctime()
}
if post['bevtype'] == 'bevtype':
post['bevtype'] = ""
posts.insert(post)
flash('Successfully saved!')
return render_template('index.html',form=form)
def mainPage():
form = MainForm()
if request.method == 'POST':
order = form.choice.raw_data[0]
print('{}'.format(form.choice.raw_data[0]))
if str(order) == '2':
form = M2()
elif str(order) == '3':
form = M3()
print('Returning {}'.format(type(form)))
return render_template('matrix.html', form=form, choice=order)
return render_template('choice.html', title='Choice', form=form)
def choice():
global executeCommand
global textOutput
if request.method == "POST" and request.form.get(
'connection') == 'disconnect':
helper.disconnectFromSerialPort()
executeCommand = False
return render_template('index.html')
print('Data is {} JS0N is {}'.format(request.form.get('choice'),
request.json))
form = MainForm()
print('FOrm exec: {} output {}'.format(executeCommand, textOutput))
if request.method == "POST" and executeCommand == True:
command = form.command.raw_data[0]
textOutput += "\n" + helper.runCommandAndGetOutput(command)
form.outputText = textOutput
form.isConnected = True
form.command.raw_data[0] = ""
elif request.method == "POST":
choice = form.choice.raw_data[0]
print(choice)
helper.initialiseSerialPort(choice)
form.isConnected = True
executeCommand = True
textOutput = "Connected to " + choice + "\n"
textOutput += "AT\n" + helper.runCommandAndGetOutput('AT')
form.outputText = textOutput
form.command.data = ""
return render_template('choice.html', form=form)
def index():
form = MainForm()
if request.method == 'POST':
result = cache.get('result')
if result is None:
result = get_tweets(app, TWEET_LIMIT)
if form.validate_on_submit():
name = request.form['crypto_name']
results, sentiment, avg_sentiment = get_coin_sentiment_data(name)
return render_template('index.html',
messages=result,
form=form,
crypto_name=name,
sentiment={
'result': enumerate(results),
'sentiment': sentiment,
'avg_sent': avg_sentiment
})
else:
result = get_tweets(app, TWEET_LIMIT)
cache.set('result', result, 300)
return render_template('index.html', messages=result, form=form)
def add_birthdate(request):
if (request.method == 'POST'):
form = MainForm(request.POST)
if form.is_valid():
form.save()
return fun(request)
else:
print form.errors
else:
form = MainForm()
return render(request, 'add_birthdate.html', {'form': form})
class Main:
def __init__(self):
self.main_form = MainForm()
self.grid_form = GridForm()
self.ellipsoids_ini = self.__parse_ellipsoids()
self.ellipsoid = None
self.sphere_projection_type = None
self.sphere_projections_list = None
self.__init_ui()
@staticmethod
def __parse_ellipsoids():
path = os.path.join(PLUGIN_PATH, r'data', r'Ellipsoids.ini')
config = configparser.ConfigParser()
config.read(path)
return config
def __init_ui(self):
self.__fill_ellipsoids()
self.__fill_projections()
v = QDoubleValidator(6350000, 6379000, 3)
self.main_form.aLineEdit.setValidator(v)
self.main_form.bLineEdit.setValidator(v)
self.main_form.build.clicked.connect(self.__show_grid)
self.main_form.ellipsoid.currentIndexChanged.connect(
self.__ellipsoid_changed)
self.main_form.projectType.currentIndexChanged.connect(
self.__sphere_projection_changed)
self.main_form.fixSteps.stateChanged.connect(self.__fixed_step_changed)
self.main_form.latDeg.valueChanged.connect(self.__step_lat_deg_changed)
self.grid_form.scale.valueChanged.connect(self.__scale_changed)
self.grid_form.labelAxis.stateChanged.connect(
self.__label_axis_changed)
self.main_form.show()
def __step_lat_deg_changed(self):
form = self.main_form
if form.fixSteps.isChecked():
form.longDeg.setValue(form.latDeg.value())
def __fixed_step_changed(self):
form = self.main_form
frame = form.frameLong
fix_steps = form.fixSteps
state = fix_steps.isChecked()
if state:
frame.setEnabled(False)
form.longDeg.setValue(form.latDeg.value())
else:
frame.setEnabled(True)
def __show_grid(self):
form = self.main_form
phi0 = form.latDegPole.value(
) + form.latMinPole.value() / 60.0 + form.latSecPole.value() / 3600.0
lam0 = form.longDegPole.value(
) + form.longMinPole.value() / 60.0 + form.longSecPole.value() / 3600.0
step_phi = form.latDeg.value()
step_lam = form.longDeg.value()
scale = self.grid_form.scale.value()
sphere_projector = self.sphere_projection_type(self.ellipsoid, phi0)
plane_projector = pr.StereographicProjector(
to_sphere_projector=sphere_projector, phi0=phi0, lam0=lam0)
grid = pr.GridBuilder(to_plane_projector=plane_projector,
step_phi=step_phi,
step_lam=step_lam,
lat0=phi0,
long0=lam0)
label_axis = self.grid_form.labelAxis.isChecked()
self.grid_painter = GridPainter(self.grid_form.frame, grid, scale,
label_axis)
self.grid_form.show()
self.grid_painter.frame.update()
self.__fill_table()
def __fill_table(self):
table = self.main_form.table
lat_dict_to_show = self.grid_painter.grid.lat_dict_to_show
table_data = []
for phi, points in sorted(lat_dict_to_show.items(),
key=lambda p: p[0]):
for lam, x, y in points:
table_data.append([
ts.dms_str(phi),
ts.dms_str(lam), '{: .3f}'.format(x), '{: .3f}'.format(y)
])
table.setRowCount(len(table_data))
for i, row in enumerate(table_data):
for j, value in enumerate(row):
item = QTableWidgetItem()
item.setText(value)
table.setItem(i, j, item)
def __scale_changed(self):
scale = self.grid_form.scale.value()
self.grid_painter.scale = scale
self.grid_painter.scale_pix = scale * PPcM
self.grid_painter.frame.update()
def __label_axis_changed(self):
label_axis = self.grid_form.labelAxis.isChecked()
self.grid_painter.label_axis = label_axis
self.grid_painter.frame.update()
def __fill_ellipsoids(self):
cbox = self.main_form.ellipsoid
cbox.clear()
lst = self.ellipsoids_ini.sections()
lst.append('Пользовательский')
cbox.addItems(lst)
cbox.setCurrentIndex(cbox.findText('GSK_2011'))
self.__ellipsoid_changed()
def __fill_projections(self):
cbox = self.main_form.projectType
cbox.clear()
lst = list(sorted(SPHERE_PROJECTIONS.keys()))
cbox.addItems(lst)
cbox.setCurrentIndex(len(lst) - 1)
self.sphere_projections_list = lst
self.__sphere_projection_changed()
def __sphere_projection_changed(self):
pr_text = self.main_form.projectType.currentText()
self.sphere_projection_type = SPHERE_PROJECTIONS[pr_text]
def __ellipsoid_changed(self):
el_text = self.main_form.ellipsoid.currentText()
a_line = self.main_form.aLineEdit
b_line = self.main_form.bLineEdit
if el_text == 'Пользовательский':
a_line.setEnabled(True)
b_line.setEnabled(True)
return
a_line.setEnabled(False)
b_line.setEnabled(False)
ellipsoid = ts.EllipsoidHolder(self.ellipsoids_ini[el_text])
a_line.setText('{:.3f}'.format(ellipsoid.a))
b_line.setText('{:.3f}'.format(ellipsoid.b))
self.ellipsoid = ellipsoid
def main():
app, mainForm, window = MainForm.init()
block_dict = plugin_manager.load()
mainForm.set_blocks(block_dict)
window.show()
sys.exit(app.exec_())
def get(self, request):
context = {'form': MainForm(), 'risk_score': None}
return render(request, self.template_name, context)
def root():
form = MainForm()
if form.validate_on_submit():
return redirect(form.authorizeTransaction())
return render_template('base.html', title='Kinect Sentry Gun', form=form)
