def toggle(bus):
with bus_lock:
try:
with db('ha.db') as c:
_bus_write(c,bus,0)
time.sleep(5)
finally:
with db('ha.db') as c:
_bus_write(c,bus,1)
async def get(ctx):
allowance = not_allowed(ctx, get.name, bot)
if allowance[0]:
await bot.say(f'acess denied,channel for ={get.name} is {allowance[1]}'
)
return
db = utils.db(ctx=ctx)
query = db.query(user=True, server=True)
if len(query) == 0:
await bot.say('Need to bet once in order to use this command')
return
balance = float(query[0][4])
mult = query[0][8]
timp = query[0][5]
if time == None:
balance += 200
await bot.say('You got a refill!!Your new balance is: ' + str(balance))
db.updateTime(time.time())
db.updateBalance(balance)
else:
rtime = time.time()
diff = rtime - timp
if diff < 0:
await bot.say('You cannot get a refill yet!!')
else:
diff = round(diff / 3600)
balance += (diff + 1) * mult
await bot.say('You got a refill!!Now you got: ' + str(balance))
db.updateBalance(balance)
db.updateTime(rtime + 3600)
async def on_member_update(before, after):
old = before.name + '#' + before.discriminator
new = after.name + '#' + after.discriminator
if old != new:
db = utils.db(member=before)
db.updateUser(new)
print('updated user')
def register():
name=request.args.get('name','')
mydb=utils.db()
color = "#%s" % "".join([hex(random.randrange(0, 255))[2:] for i in range(3)])
print color;
r = mydb.add_user(name,color)
return json.dumps(r);
def authorize(url):
db = utils.db()['db']
code = url.split("?code=")[1].split("&")[0]
payload = {'redirect_uri': utils.config('callback_uri'),
'code': code,
'grant_type': 'authorization_code',
'scope': utils.config('scope')}
auth_header = base64.b64encode(six.text_type(utils.config('client_id') + ':' + utils.config('client_secret')).encode('ascii'))
headers = {'Authorization': 'Basic %s' % auth_header.decode('ascii')}
results = requests.post('https://accounts.spotify.com/api/token', data=payload, headers=headers)
token_info = results.json()
token_info['expires_at'] = int(time.time()) + token_info['expires_in']
token_info['client_id'] = utils.config('client_id')
token_info['client_secret'] = utils.config('client_secret')
token_info['prefix'] = utils.config('prefix')
token_info['scope'] = utils.config('scope')
db.insert(token_info)
utils.output('end', 'success', utils.translate('logged'))
def update():
name=request.args.get('name','')
x=int(request.args.get('x','-1'))
y=int(request.args.get('y','-1'))
mydb=utils.db()
mydb.cleanup()
mydb.update(name,x,y)
return "True"
def update(id, bus_id, name, addr):
with db("ha.db") as c:
if bus_id is not None:
c.execute("update device set bus_id=? where id=?", (bus_id, id))
if name is not None:
print "update:" + str(name) + " id " + str(id)
c.execute("update device set name=? where id=?", (name, id))
if addr is not None:
c.execute("update device set address=? where id=?", (addr, id))
def plot_time_series(self,
f_start=None,
f_stop=None,
if_id=0,
logged=True,
orientation='h',
MJD_time=False,
**kwargs):
""" Plot the time series.
Args:
f_start (float): start frequency, in MHz
f_stop (float): stop frequency, in MHz
logged (bool): Plot in linear (False) or dB units (True),
kwargs: keyword args to be passed to matplotlib imshow()
"""
ax = plt.gca()
plot_f, plot_data = self.grab_data(f_start, f_stop, if_id)
if logged and self.header[b'nbits'] >= 8:
plot_data = db(plot_data)
#Since the data has been squeezed, the axis for time goes away if only one bin, causing a bug with axis=1
if len(plot_data.shape) > 1:
plot_data = plot_data.mean(axis=1)
else:
plot_data = plot_data.mean()
#Make proper time axis for plotting (but only for plotting!). Note that this makes the values inclusive.
extent = self._calc_extent(plot_f=plot_f,
plot_t=self.timestamps,
MJD_time=MJD_time)
plot_t = np.linspace(extent[2], extent[3], len(self.timestamps))
if MJD_time:
tlabel = "Time [MJD]"
else:
tlabel = "Time [s]"
if logged:
plabel = "Power [dB]"
else:
plabel = "Power [counts]"
# Reverse oder if vertical orientation.
if 'v' in orientation:
plt.plot(plot_data, plot_t, **kwargs)
plt.xlabel(plabel)
else:
plt.plot(plot_t, plot_data, **kwargs)
plt.xlabel(tlabel)
plt.ylabel(plabel)
ax.autoscale(axis='both', tight=True)
def NoSS_old(X, EigDiffCutoff=4):
"""Older way of finding the SignalEndIdx based on thresholding and
eigenvalue difference cutoff
Args:
X: CSI, shape=[count, subcarriers, nrx]
EigDiffCutoff: eigenvalue difference cutoff
Refs:
1. GetQnBackscatter.m: line 50-64
"""
R = (X @ X.transpose(0, 2, 1).conj()).mean(axis=0)
w, v = eigh(R)
w = sorted(np.abs(w), reverse=True)[:5]
Criterion1 = np.diff(db(w)) <= max(-EigDiffCutoff, min(db(w)))
Criterion3 = w[:-1] / w[0] > 0.03
index, = np.nonzero(Criterion1 * Criterion3)
return index[-1] + 1
def plot_waterfall(self, f_start=None, f_stop=None, if_id=0, logged=True, cb=True, MJD_time=False, **kwargs):
""" Plot waterfall of data
Args:
f_start (float): start frequency, in MHz
f_stop (float): stop frequency, in MHz
logged (bool): Plot in linear (False) or dB units (True),
cb (bool): for plotting the colorbar
kwargs: keyword args to be passed to matplotlib imshow()
"""
plot_f, plot_data = self.grab_data(f_start, f_stop, if_id)
#Using accending frequency for all plots.
if self.header[b'foff'] < 0:
plot_data = plot_data[..., ::-1] # Reverse data
plot_f = plot_f[::-1]
if logged:
plot_data = db(plot_data)
# Make sure waterfall plot is under 4k*4k
dec_fac_x, dec_fac_y = 1, 1
if plot_data.shape[0] > MAX_IMSHOW_POINTS[0]:
dec_fac_x = int(plot_data.shape[0] / MAX_IMSHOW_POINTS[0])
if plot_data.shape[1] > MAX_IMSHOW_POINTS[1]:
dec_fac_y = int(plot_data.shape[1] / MAX_IMSHOW_POINTS[1])
plot_data = rebin(plot_data, dec_fac_x, dec_fac_y)
try:
plt.title(self.header[b'source_name'])
except KeyError:
plt.title(self.filename)
extent = self._calc_extent(plot_f=plot_f,plot_t=self.timestamps,MJD_time=MJD_time)
plt.imshow(plot_data,
aspect='auto',
origin='lower',
rasterized=True,
interpolation='nearest',
extent=extent,
cmap='viridis',
**kwargs
)
if cb:
plt.colorbar()
plt.xlabel("Frequency [MHz]")
if MJD_time:
plt.ylabel("Time [MJD]")
else:
plt.ylabel("Time [s]")
def history(bus,interval,steps,after):
with db('ha.db') as c:
_bus_read(c,bus)
t = int(time.time())
newafter = c.cursor().execute('SELECT MAX(last_updated) FROM bus_history WHERE bus_id=?',(bus,)).fetchall()[0];
if newafter == after:
return []
data = c.cursor().execute('SELECT last_updated,status FROM bus_history WHERE bus_id=? AND last_updated >= ? ORDER BY id DESC',(bus,t - interval)).fetchall()
data.insert(0, [t,_bus_read(c,bus)])
h = history2plot(t, interval, steps, data)
return {'history':h,'after': t}
async def balance(ctx, member: discord.Member = None):
allowance = not_allowed(ctx, balance.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={balance.name} is {allowance[1]}')
return
if member != None:
db = utils.db(member=member)
else:
db = utils.db(ctx=ctx)
n = db.query(user=True, server=True)
embed = discord.Embed(title='BALANCE',
description='',
colour=discord.Colour.gold())
if len(n) > 0:
embed.add_field(name=f'{db.userName} balance is:', value=f'{n[0][4]}')
else:
embed.add_field(name='Your balance is:', value='20000')
await bot.say(embed=embed)
async def give(ctx, user: discord.Member, amount):
allowance = not_allowed(ctx, give.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={give.name} is {allowance[1]}')
return
if user == None:
await bot.say('ENTER A USER, like this ->@User#1111')
return
elif user.id == ctx.message.author.id:
await bot.say('You cant donate to yourself')
return
n = utils.Check(ctx)
db = utils.db(ctx=ctx)
user = utils.db(member=user)
userQuery = user.query(user=True, server=True)
donator = db.query(user=True, server=True)
if len(userQuery) == 0 or len(donator) == 0:
await bot.say(
'The giving or receiving user needs to bet at least once!!')
return
balance = n.balance()
amount = utils.Check.amount(amount, balance)
if n.broke(amount, balance):
await n.display(amount, balance, bot)
return
else:
balance -= amount
db.updateBalance(balance)
don = userQuery[0][4]
don = float(don) + amount
user.updateBalance(don)
await bot.say(f'{user.userName} got a donation of {amount}!!')
def discover(i2c_addr):
with habus.bus_lock:
try:
with db('ha.db') as c:
habus._bus_write(c,1,0)
time.sleep(6)
finally:
with db('ha.db') as c:
habus._bus_write(c,1,1)
timeout = 5 # 5 seconds timeout for device discovery, you need to poweroff/poweron device during this timeframe
while True:
if timeout <= 0:
raise IOError('device was not discovered in 5 seconds')
try:
bus.write_word_data(i2c_addr, 0x01, 0x200)
if bus.read_word_data(i2c_addr, 0x01) == 0x200:
return i2c_addr
except IOError,err:
time.sleep(1.0)
timeout -= 1
continue
time.sleep(1.0)
timeout -= 1
def story(title=""):
mydb = utils.db()
if request.method == 'GET':
lines = mydb.returnStory(title)
return render_template('storytemp.html', title=title, lines=lines)
else:
button=request.form.get('button', None)
title=request.form.get('title', "")
new_line=request.form.get('new_line', "")
if button == 'Add':
mydb.addLineToStory(title, new_line)
return redirect("/story/%s" %(title))
elif button == 'Delete':
mydb.removeAStory(title)
return redirect("/")
else:
return redirect("/")
def home():
mydb = utils.db()
if request.method=='POST':
button=request.form.get('button', None)
new_story=request.form.get('new_story', "")
selected=request.form.get('title', "")
if button=="Choose story":
url=urllib2.quote("/story/%s" %(selected))
return redirect(url)
if button=="Create story" and len(new_story)>0:
mydb.addStory(new_story)
return redirect("/")
elif button=="Drop stories":
mydb.removeStories()
return redirect("/")
titles = mydb.returnTitles()
return render_template('template.html',titles=titles)
def _bus_checks():
while True:
time.sleep(5)
try:
with bus_lock:
with db('ha.db') as c:
bus1 = _bus_read(c,1)
if not bus1:
_bus_write(c,1,1)
bus2 = _bus_read(c,2)
if not bus2:
_bus_write(c,2,1)
bus3 = _bus_read(c,3)
if not bus3:
_bus_write(c,3,1)
except KeyboardInterrupt:
break
except Exception,ex:
print "exception happened during periodic bus status check:"+str(ex)
async def slot(ctx, amount):
allowance = not_allowed(ctx, slot.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={slot.name} is {allowance[1]}')
return
db = utils.db(ctx)
check = utils.Check(ctx)
lev = level.Level(ctx)
balance = check.balance()
amount = utils.Check.amount(amount, balance)
if utils.Check.broke(amount, balance):
await check.display(amount, balance, bot)
return
else:
Slot = game.slot(balance, amount, ctx)
grid = Slot.generate()
win = Slot.check_win(grid)
if not win:
balance = Slot.new_balance(win)
check.embed.add_field(
name=f'{db.userName} YOU LOST now you have {balance} left',
value=Slot.display(grid))
else:
balance = Slot.new_balance(win)
check.embed.add_field(
name=f'{db.userName} YOU WON now you got {balance}',
value=Slot.display(grid))
lev.get_level()
lev.evaluate(amount)
db.updateBalance(balance)
await bot.say(embed=check.embed)
log = statistics.bet_log(ctx)
log.update_count()
async def dice(ctx, range, amount):
allowance = not_allowed(ctx, dice.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={dice.name} is {allowance[1]}')
return
db = utils.db(ctx)
check = utils.Check(ctx)
lev = level.Level(ctx)
balance = check.balance()
amount = utils.Check.amount(amount, balance)
if '-' not in range:
await bot.say(f'add a - to your range like this -> 30-80')
return
if utils.Check.broke(amount, balance):
await check.display(amount, balance, bot)
return
else:
Dice = game.dice(range, amount, balance, ctx)
Dice.update_balance()
if Dice.win():
check.embed.add_field(
name=f'{ctx.message.author} you won it rolled {Dice.choice}!!!',
value=f'New balance:{Dice.balance}')
else:
check.embed.add_field(
name=
f'{ctx.message.author} you LOST it rolled {Dice.choice}!!!',
value=f'New balance:{Dice.balance}')
log = statistics.bet_log(ctx)
log.update_count()
await bot.say(embed=check.embed)
async def lead(ctx, top: int = None):
allowance = not_allowed(ctx, lead.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={lead.name} is {allowance[1]}')
return
db = utils.db(ctx=ctx)
n = db.query(server=True)
f = [[n[i][4], n[i][3]] for i in range(0, len(n))]
info = sorted(f)
length = len(n)
user = []
balance = []
finalBalance = []
for i in range(0, length):
user.insert(i, info[i][1])
balance.insert(i, info[i][0])
finalBalance.insert(i, info[i][0])
embed = discord.Embed(tite='LEADERBOARD',
description='',
colour=discord.Colour.purple())
ranks = [None] * length
pos = 1
while None in ranks:
biggest = balance[-1]
index = [i for i, x in enumerate(balance) if x == biggest]
for i in index:
ranks[i] = pos
pos += 1
del balance[index[0]:index[-1] + 1]
embed = level.lead.Display(ranks, finalBalance, user, embed, top)
await bot.say(embed=embed)
async def gamble(ctx, amount):
allowance = not_allowed(ctx, gamble.name, bot)
if allowance[0]:
await bot.say(
f'acess denied, channel for ={gamble.name} is {allowance[1]}')
return
n = utils.Check(ctx)
db = utils.db(ctx)
lev = level.Level(ctx)
balance = n.balance()
amount = utils.Check.amount(amount, balance)
if utils.Check.broke(amount, balance):
await n.display(amount, balance, bot)
return
else:
rn = random.randint(0, 1)
if rn == 0:
balance += amount
n.embed.add_field(name=f'{n.info.userName} YOU WON!!!',
value=f'New balance: {balance}')
if rn == 1:
balance -= amount
n.embed.add_field(name=f"{n.info.userName} YOU LOST",
value=f'New balance: {balance}')
lev.get_level()
lev.evaluate(amount)
await bot.say(embed=n.embed)
db.updateBalance(balance)
log = statistics.bet_log(ctx)
log.update_count()
async def on_ready():
print("i was born read eksdi lol xddd 420 69")
print("I am running as " + bot.user.name)
print("With the ID: " + bot.user.id)
print(discord.__version__)
search = utils.db()
query = search.query()
t1 = time.time()
for i in range(0, len(query)):
user = await bot.get_user_info(query[i][1])
username = user.name + '#' + user.discriminator
if query[i][3] != username:
with sqlite3.connect('info.db') as conn:
c = conn.cursor()
c.execute('UPDATE value SET userName=(?) WHERE userName=(?)', (
username,
query[i][3],
))
conn.commit()
t2 = time.time()
delta = str(t2 - t1)
print('finished checking in: ' + delta + ' seconds')
'''
def getBalls():
name = str(request.args.get('name',''))
mydb=utils.db()
return json.dumps(mydb.get_balls(name))
def generate_report(app_id):
reviews_table = db()['reviews']
reviews = [r for r in reviews_table.find({'appId': app_id})]
sia = SentimentIntensityAnalyzer()
analysed_reviews = []
def normalize(data):
url_pattern = re.compile(r'https?://\S+|www\.\S+')
data = url_pattern.sub(r'', data)
data = re.sub('\S*@\S*\s?', '', data)
data = re.sub('\s+', ' ', data)
data = re.sub("\'", "", data)
return data
def analyse_review(review):
score_c = score_t = {'neg': 0, 'neu': 1, 'pos': 0, 'compound': 0}
if review.get('title'):
score_t = sia.polarity_scores(normalize(review['title']))
if review.get('content'):
score_c = sia.polarity_scores(normalize(review['content']))
title_coeff = 0.05
content_coeff = 0.95
merged_score = {}
for key in score_c:
merged_score[key] = title_coeff * float(
score_t[key]) + content_coeff * float(score_c[key])
merged_score['compound'] = (merged_score['compound'])
return merged_score
for r in reviews:
score = analyse_review(r)
analysed_reviews.append({str(r['_id']): score})
sorted_analysed_reviews = sorted(
analysed_reviews, key=lambda k: list(k.values())[0]['compound'])
labels = []
for sar in sorted_analysed_reviews:
compound = list(sar.values())[0]['compound']
if (compound <= -0.5):
labels.append("Terrible")
elif (-0.5 < compound < -0.05):
labels.append("Bad")
elif (-0.05 < compound < 0.05):
labels.append("Satisfactory")
elif (0.05 < compound < 0.5):
labels.append("Good")
elif (compound >= 0.5):
labels.append("Excellent")
return {
'bad_reviews': json.dumps(sorted_analysed_reviews[0:10]),
'good_reviews': json.dumps(sorted_analysed_reviews[-10:]),
'verdict': Counter(labels).most_common(1)[0][0],
}
def attack():
nameTar=str(request.args.get('tarName',''))
newHealth=int(request.args.get('dmg','-1'))
mydb=utils.db()
mydb.takeDmg(nameTar,newHealth)
return "Attacked"
def plot_spectrum_min_max(self,
t=0,
f_start=None,
f_stop=None,
logged=False,
if_id=0,
c=None,
**kwargs):
""" Plot frequency spectrum of a given file
Args:
logged (bool): Plot in linear (False) or dB units (True)
if_id (int): IF identification (if multiple IF signals in file)
c: color for line
kwargs: keyword args to be passed to matplotlib plot()
"""
ax = plt.gca()
plot_f, plot_data = self.grab_data(f_start, f_stop, if_id)
#Using accending frequency for all plots.
if self.header[b'foff'] < 0:
plot_data = plot_data[..., ::-1] # Reverse data
plot_f = plot_f[::-1]
fig_max = plot_data[0].max()
fig_min = plot_data[0].min()
print("averaging along time axis...")
#Since the data has been squeezed, the axis for time goes away if only one bin, causing a bug with axis=1
if len(plot_data.shape) > 1:
plot_max = plot_data.max(axis=0)
plot_min = plot_data.min(axis=0)
plot_data = plot_data.mean(axis=0)
else:
plot_max = plot_data.max()
plot_min = plot_data.min()
plot_data = plot_data.mean()
# Rebin to max number of points
dec_fac_x = 1
MAX_PLT_POINTS = 8 * 64 # Low resoluition to see the difference.
if plot_data.shape[0] > MAX_PLT_POINTS:
dec_fac_x = int(plot_data.shape[0] / MAX_PLT_POINTS)
plot_data = rebin(plot_data, dec_fac_x, 1)
plot_min = rebin(plot_min, dec_fac_x, 1)
plot_max = rebin(plot_max, dec_fac_x, 1)
plot_f = rebin(plot_f, dec_fac_x, 1)
if logged:
plt.plot(plot_f, db(plot_data), "#333333", label='mean', **kwargs)
plt.plot(plot_f, db(plot_max), "#e74c3c", label='max', **kwargs)
plt.plot(plot_f, db(plot_min), '#3b5b92', label='min', **kwargs)
plt.ylabel("Power [dB]")
else:
plt.plot(plot_f, plot_data, "#333333", label='mean', **kwargs)
plt.plot(plot_f, plot_max, "#e74c3c", label='max', **kwargs)
plt.plot(plot_f, plot_min, '#3b5b92', label='min', **kwargs)
plt.ylabel("Power [counts]")
plt.xlabel("Frequency [MHz]")
plt.legend()
try:
plt.title(self.header[b'source_name'])
except KeyError:
plt.title(self.filename)
plt.xlim(plot_f[0], plot_f[-1])
if logged:
plt.ylim(db(fig_min), db(fig_max))
def _bus_write(c,bus,value):
if value:
value = 0
else:
value = 1
print 'writing to port:'+str(value)
GPIO.output(28,value)
status = GPIO.input(29)
if status:
value = 0
else:
value = 1
c.execute('UPDATE bus set status = ? WHERE id = ?',(status,bus))
# poweron on startup
try:
with db('ha.db') as c:
_bus_write(c,1,1)
except Exception,ex:
print "failed to initially poweron bus, error:"+str(ex)
#pediodic timer to update periodically our main bus
def _bus_checks():
while True:
time.sleep(5)
try:
with bus_lock:
with db('ha.db') as c:
bus1 = _bus_read(c,1)
if not bus1:
_bus_write(c,1,1)
bus2 = _bus_read(c,2)
import utils
import time
from tinydb import TinyDB, Query
import requests
import json
import base64
import socket
from urllib.parse import urlencode
import webbrowser
import six
db = utils.db()['db']
data = db.all()[0]
access_token = data['access_token']
expires_at = data['expires_at']
refresh_token = data['refresh_token']
client_id = data['client_id']
client_secret = data['client_secret']
prefix = data['prefix']
def getAccessToken():
global access_token
now = int(time.time())
if expires_at - now < 60:
access_token = refreshAccessToken(refresh_token, db)
return access_token
def plot_spectrum(self,
t=0,
f_start=None,
f_stop=None,
logged=False,
if_id=0,
c=None,
**kwargs):
""" Plot frequency spectrum of a given file
Args:
t (int): integration number to plot (0 -> len(data))
logged (bool): Plot in linear (False) or dB units (True)
if_id (int): IF identification (if multiple IF signals in file)
c: color for line
kwargs: keyword args to be passed to matplotlib plot()
"""
if self.header[b'nbits'] <= 2:
logged = False
t = 'all'
ax = plt.gca()
plot_f, plot_data = self.grab_data(f_start, f_stop, if_id)
#Using accending frequency for all plots.
if self.header[b'foff'] < 0:
plot_data = plot_data[..., ::-1] # Reverse data
plot_f = plot_f[::-1]
if isinstance(t, int):
print("extracting integration %i..." % t)
plot_data = plot_data[t]
elif t == b'all':
print("averaging along time axis...")
#Since the data has been squeezed, the axis for time goes away if only one bin, causing a bug with axis=1
if len(plot_data.shape) > 1:
plot_data = plot_data.mean(axis=0)
else:
plot_data = plot_data.mean()
else:
raise RuntimeError("Unknown integration %s" % t)
# Rebin to max number of points
dec_fac_x = 1
if plot_data.shape[0] > MAX_PLT_POINTS:
dec_fac_x = int(plot_data.shape[0] / MAX_PLT_POINTS)
plot_data = rebin(plot_data, dec_fac_x, 1)
plot_f = rebin(plot_f, dec_fac_x, 1)
if not c:
kwargs['c'] = '#333333'
if logged:
plt.plot(plot_f, db(plot_data), label='Stokes I', **kwargs)
plt.ylabel("Power [dB]")
else:
plt.plot(plot_f, plot_data, label='Stokes I', **kwargs)
plt.ylabel("Power [counts]")
plt.xlabel("Frequency [MHz]")
plt.legend()
try:
plt.title(self.header[b'source_name'])
except KeyError:
plt.title(self.filename)
plt.xlim(plot_f[0], plot_f[-1])
async def roll(ctx, amount, choice):
allowance = not_allowed(ctx, roll.name, bot)
if allowance[0]:
await bot.say(
f'acess denied,channel for ={roll.name} is {allowance[1]}')
return
p = ['r', 'b', 'g']
if choice != 'r' and choice != 'b' and choice != 'g':
await bot.say(
f'INVALID CHOICE,type {p[0]} for red,{p[1]} for black and {p[2]} for green'
)
return
n = utils.Check(ctx)
db = utils.db(ctx)
lev = level.Level(ctx)
balance = n.balance()
amount = utils.Check.amount(amount, balance)
emoji = {'r': ':red_circle:', 'b': ':black_circle:', 'g': ':green_apple:'}
rn = random.randint(0, 16)
display = ''
win = ''
if rn == 16:
win = 'g'
elif rn % 2 == 0:
win = 'r'
elif rn % 2 != 0:
win = 'b'
for i in range(0, 9):
if rn == 16:
display += emoji['g']
rn = 0
elif rn % 2 == 0:
display += emoji['r']
rn += 1
else:
display += emoji['b']
rn += 1
cursor = ':point_up:'
if utils.Check.broke(amount, balance):
await n.display(amount, balance, bot)
return
else:
if win == choice:
if choice == 'g':
balance += amount * 14
n.embed.add_field(
name=display + '\n' + cursor + '\n' +
f'{db.userName} you won,ON GREEN!!! balance->' +
str(balance),
value='--------------------')
else:
balance += amount
n.embed.add_field(name=display + '\n' + cursor + '\n' +
f'{db.userName} you won,new balance is ->' +
str(balance),
value='------------------')
else:
balance -= amount
n.embed.add_field(name=display + '\n' + cursor + '\n' +
f'{db.userName} you lost,new balance is ->' +
str(balance),
value='----------------------')
lev.get_level()
lev.evaluate(amount)
db.updateBalance(balance)
await bot.say(embed=n.embed)
log = statistics.bet_log(ctx)
log.update_count()
def update(bus, onoff):
with db('ha.db') as c:
_bus_write(c,bus, onoff)
def getBalls():
mydb=utils.db()
return json.dumps(mydb.get_balls())
def users():
#name=request.args.get('name','')
mydb=utils.db()
return json.dumps(mydb.get_users())
def create(bus_id, name, addr):
with db("ha.db") as c:
c.execute("insert into device(bus_id,name,address) values (?,?,?)", (bus_id, name, addr))
def delete(id):
with db("ha.db") as c:
c.execute("delete from device where id=?", (id,))
def list():
with db("ha.db") as c:
return c.cursor().execute("SELECT * FROM device").fetchall()
def getPolygons():
mydb=utils.db()
return json.dumps(mydb.get_polygons())
def bus(id):
with db("ha.db") as c:
return c.cursor().execute("SELECT bus_id FROM device WHERE id=?", (id,)).fetchall()[0][0]
def register():
name=request.args.get('name','')
mydb=utils.db()
r = mydb.add_user(name)
return json.dumps(r);
global start_from
global year
global dir_in
global dir_pdfs
global illinois_entities_xlsx_file
global illinois_entities_sheet
global script_name
start_time = datetime.utcnow()
script_name = "get_IL.py"
result = 1
error_message = ""
config_file = ""
config = configparser.ConfigParser()
config.read('conf.ini')
db = db(config)
try:
dbparameters = db.readProps('illinois')
config_file = str(dbparameters)
with open('IL_parms.txt', 'r') as fp:
dparameters = json.load(fp)
ftpurl = dbparameters["url"] or dparameters["ftpurl"]
url = urllib.parse.urlparse(ftpurl)
start_from = dbparameters["start_from"] or dparameters["start_from"]
year = dbparameters["year"] or dparameters["year"]
dir_in = dbparameters["dir_in"] or dparameters["dir_in"]
dir_pdfs = dbparameters["dir_pdfs"] or dparameters["dir_pdfs"]
illinois_entities_xlsx_file = dbparameters[
"illinois_entities_xlsx_file"] or dparameters[
"illinois_entities_xlsx_file"]
illinois_entities_sheet = dbparameters[
def run(string, entities):
"""Download new videos from a YouTube playlist"""
db = utils.db()['db']
query = utils.db()['query']
operations = utils.db()['operations']
apikey = utils.config('api_key')
playlistid = utils.config('playlist_id')
# https://developers.google.com/youtube/v3/docs/playlistItems/list
url = 'https://www.googleapis.com/youtube/v3/playlistItems?part=snippet&maxResults=50&playlistId=' + playlistid + '&key=' + apikey
utils.output('inter', 'reaching_playlist', utils.translate('reaching_playlist'))
# Get videos from the playlist
try:
r = utils.http('GET', url)
# In case there is a problem like wrong settings
if 'error' in r.json():
error = r.json()['error']['errors'][0]
return utils.output('settings_error', 'settings_error', utils.translate('settings_errors', {
'reason': error['reason'],
'message': error['message']
}))
items = r.json()['items']
videoids = []
videos = []
for item in items:
resource = item['snippet']['resourceId']
if resource['kind'] == 'youtube#video':
videoids.append(resource['videoId'])
videos.append({
'id': resource['videoId'],
'title': item['snippet']['title']
})
except requests.exceptions.RequestException as e:
return utils.output('request_error', 'request_error', utils.translate('request_errors'))
Entry = query()
# First initialization
if db.count(Entry.platform == 'youtube') == 0:
db.insert({
'platform': 'youtube',
'checked_at': int(time()),
'downloaded_videos': []
})
else:
db.update({ 'checked_at': int(time()) }, Entry.platform == 'youtube')
# Get videos already downloaded
downloadedvideos = db.get(Entry.platform == 'youtube')['downloaded_videos']
todownload = []
for video in videos:
if video['id'] not in downloadedvideos:
todownload.append(video)
nbrtodownload = len(todownload)
if nbrtodownload == 0:
return utils.output('nothing_to_download', 'nothing_to_download', utils.translate('nothing_to_download'))
utils.output('inter', 'nb_to_download', utils.translate('nb_to_download', {
'nb': nbrtodownload
}))
# Create the module downloads directory
moduledldir = utils.createdldir()
for i, video in enumerate(todownload):
utils.output('inter', 'downloading', utils.translate('downloading', {
'video_title': video['title']
}))
# Download the video
yt = YouTube('https://youtube.com/watch?v=' + video['id'])
yt.streams.first().download(moduledldir)
# Add the new downloaded video to the DB
downloadedvideos.append(video['id'])
db.update({ 'downloaded_videos': downloadedvideos }, Entry.platform == 'youtube')
# Will synchronize the content (because "end" type) if synchronization enabled
return utils.output('end', 'success', utils.translate('success'))
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import requests
import utils
from time import time
# Package database
db = utils.db()['db']
# Lists of the module table
db_lists = db.table('todo_lists')
# Todos of the module table
db_todos = db.table('todo_todos')
# Query
Query = utils.db()['query']()
# Time stamp
timestamp = int(time())
def create_list(string, entities):
"""Create a to-do list"""
# List name
listname = ''
# Find entities
for item in entities:
if item['entity'] == 'list':
listname = item['sourceText'].lower()
