async def name(self, ctx):
perm = self.perm(ctx)
if perm:
return await ctx.send(perm)
update_data(self.data)
content = ctx.message.content.split()
voice = ctx.author.voice
guild_id = str(ctx.guild.id)
if not voice:
return self.name.reset_cooldown(ctx)
chan = voice.channel
voice_id = str(voice.channel.id)
if voice_id not in self.data[guild_id]['channels'].keys():
return self.name.reset_cooldown(ctx)
if ctx.author.id != self.data[guild_id]['channels'][voice_id]:
return self.name.reset_cooldown(ctx)
if len(content) > 2:
await chan.edit(name=" ".join(content[2:]))
await ctx.message.channel.send("Name successfully changed.")
else:
return self.name.reset_cooldown(ctx)
def test_update_data_entry_2(self):
utils.update_data(entry = self.entry_2,
vdata = self.vdata,
fdata = self.fdata,
vdata_next_mo = self.vdata_next_mo,
fdata_next_mo = self.fdata_next_mo,
trips = self.trips,
w = self.w,
h = self.h,
n = self.n)
self.assertEqual(self.vdata[0,0,0,0,0], 0) # pcount at start
self.assertEqual(self.vdata[0,0,0,0,1], 0) # tcount at start
self.assertEqual(self.vdata[1,0,0,1,0], 61) # pcount at end
self.assertEqual(self.vdata[1,0,0,1,1], 1) # tcount at end
self.assertEqual(self.fdata[0,1,0,0,0,0,0], 61) # Dif time slots, so fdata[0] should be all 0s
self.assertEqual(self.fdata[0,1,0,0,0,0,1], 1)
self.assertEqual(self.fdata[1,1,0,0,0,0,0], 0) # Dif time slots, we're looking at the end time (t=1)
self.assertEqual(self.fdata[1,1,0,0,0,0,1], 0)
self.assertEqual(self.trips[0,0,0], 61)
self.assertEqual(self.trips[0,0,1], 1)
self.assertEqual(self.trips[0,1,0], 0)
self.assertEqual(self.trips[0,1,1], 0)
self.assertEqual(self.trips[1,0,0], 0)
self.assertEqual(self.trips[1,0,1], 0)
self.assertEqual(self.trips[1,1,0], 0)
self.assertEqual(self.trips[1,1,1], 0)
def add_letter(message):
user = message.from_user.id
params = utils.get_data(user, "params")
cyr = "абвгдежзийклмнопрстуфхцчшэюя"
lat = "abcdefghijklmnopqrstuvwxyz"
bad_letters = "ыьщ"
if len(message.text) > 1:
txt = "Мне нужна только одна буква"
msg = bot.send_message(message.chat.id, txt)
bot.register_next_step_handler(msg, add_letter)
else:
if message.text.lower() in bad_letters:
txt = "Очень смешно... давай по нормальному"
msg = bot.send_message(message.chat.id, txt)
bot.register_next_step_handler(msg, add_letter)
elif params["lang"] == "cyr" and message.text.lower() not in cyr:
txt = "Это не русская буква, а ты выбрал кирилицу, не надо так)\nДавай еще раз"
msg = bot.send_message(message.chat.id, txt)
bot.register_next_step_handler(msg, add_letter)
elif params["lang"] == "lat" and message.text.lower() not in lat:
txt = "Это не латинская буква, а ты выбрал латинницу, не надо так)\nДавай еще раз"
msg = bot.send_message(message.chat.id, txt)
bot.register_next_step_handler(msg, add_letter)
else:
utils.update_data(user, params={"name": f"{message.text.upper()}"},
filters={"name": f"На букву {message.text.upper()}"})
send_for_params(message)
def send_random(message):
conn = utils.SQLighter(cfg.database)
user = message.from_user.id
response_list = conn.get_random()
utils.update_data(user, response_list=response_list)
txt = f"""Твое случайное имя {random.choice(response_list)}?"""
bot.send_message(message.chat.id, txt, reply_markup=start_keyboard())
async def on_voice_state_update(member, before, after):
# if the user connects to the set voice channel...
if after.channel and after.channel.id == data[str(
member.guild.id)]['main']:
category = bot.get_channel(after.channel.category_id)
# create a new channel, named after the member name, set permissions, and move the member to it
change = await member.guild.create_voice_channel(
f"{member.name}'s channel", category=category)
await change.set_permissions(member, view_channel=True, connect=True)
await member.move_to(change)
logger.info(
f"{member.name} joined and was moved to \"{member.name}'s channel\""
)
# update the data
data[str(member.guild.id)]["channels"][str(change.id)] = member.id
# if the user disconnects from a personnal voice channel
if before.channel and str(before.channel.id) in data[str(
member.guild.id)]["channels"]:
if not len(
before.channel.members
): # if there is no more users in the voice channel, delete it
data[str(member.guild.id)]['channels'].pop(str(before.channel.id))
await before.channel.delete(reason='Last member leave')
logger.info(
f"Personnal voice channel \"{before.channel.name}\" is empty so it has been deleted."
)
update_json(data)
update_data(data)
async def set_channel(self, ctx):
content = ctx.message.content.split()
if len(content) <= 1:
await ctx.send("Please specify a channel id.")
return
if not content[1].isdigit():
await ctx.send("Please use a valid id.")
return
channel = self.bot.get_channel(int(content[1]))
if not channel:
await ctx.send("Please use a valid id.")
return
if not isinstance(channel, discord.VoiceChannel):
await ctx.send("Please use a voice channel id.")
return
if self.data[str(ctx.guild.id)]["main"] is not None:
self.logger.warning(
f"Channel already set {self.data[str(ctx.guild.id)]['main']}.")
self.logger.info(f"Set main channel <{channel.name}.{channel.id}>")
self.data[str(ctx.guild.id)]['main'] = channel.id
await ctx.send("Main channel set.")
update_json(self.data)
update_data(self.data)
async def on_guild_join(guild):
update_data(data)
data[str(guild.id)] = {"main": None, "channels": {}}
game = discord.Game(f"Manage {len(bot.guilds)} servers")
await bot.change_presence(activity=game)
update_json(data)
async def on_guild_remove(guild):
update_data(data)
del data[str(guild.id)]
game = discord.Game(f"Manage {len(bot.guilds)} servers")
await bot.change_presence(activity=game)
update_json(data)
def update(conf):
conf.update({
'source': 'reddit',
'doc_type': 'posts',
'url': 'http://www.reddit.com/r/{}'.format(conf['reddit'])
})
update_data(conf, get_posts(conf))
def update(conf):
conf.update({
'source': 'stackoverflow',
'doc_type': 'bounties',
'url': URL_TEMPLATE.format(conf['stackoverflow'])
})
update_data(conf, get_posts(conf))
def update(conf):
conf.update({
'source': 'github',
'doc_type': 'repositories',
'url': URL_TEMPLATE.format(conf['github'])
})
update_data(conf, get_posts(conf))
async def unset_channel(self, ctx):
self.data[str(ctx.guild.id)]['main'] = None
await ctx.send("Main channel reset.")
self.logger.info("Main channel reset.")
update_json(self.data)
update_data(self.data)
async def _set(self, ctx):
update_data(self.data)
content = ctx.message.content.split()
keywords = [
"private", "public", "owner", "places", "name", "hide", "reveal",
"invite", "kick"
]
if len(content) <= 1 or content[1] not in keywords:
await ctx.send(embed=config_help_embed(ctx.author))
def cloudsight_process_result(image, result):
if result is None or result['status'] == 'timeout':
return
print image, result
if result['status'] == 'completed':
resultdict[image]['cloudsight'] = (result['status'], result['name'])
else:
resultdict[image]['cloudsight'] = (result['status'], result['reason'])
update_data(resultdict)
async def on_ready():
update_data(data)
logger.info(f"Bot logged as {bot.user.name}")
for guild in bot.guilds:
if str(guild.id) not in data.keys():
data[str(guild.id)] = {"main": None, "channels": {}}
game = discord.Game(f"Manage {len(bot.guilds)} servers")
await bot.change_presence(activity=game)
update_json(data)
async def owner(self, ctx):
perm = self.perm(ctx)
if perm:
return await ctx.send(perm)
update_data(self.data)
guild_id = str(ctx.guild.id)
if len(ctx.message.mentions):
self.data[guild_id]['channels'][str(ctx.author.voice.channel.id)] = ctx.message.mentions[0].id
await ctx.message.channel.send(f"Owner successfully changed to {ctx.message.mentions[0].name}.")
update_json(self.data)
def train(parameters, X, logg, model, saver, sess, y):
for i in range(parameters.num_data_perturbations):
epoch_counter = range(
parameters.num_epochs
) if parameters.num_epochs else itertools.count()
for j in epoch_counter:
feed = {
model.input_ph: X,
model.output_ph: y[:, None],
}
loss, _ = sess.run([model.loss, model.update_op], feed)
logg.record(i, j, loss)
if j % 100 == 0:
logger.info('Loss at data perturb %i epoch %i: %f', i, j, loss)
if loss < parameters.loss_cutoff:
parameters.loss_cutoff *= 1.03
logger.info('Num iterations to convergence: %i', j)
break
X, y = update_data(X, y)
saver.save(sess,
os.path.join(parameters.model_dir_path, 'model'),
global_step=i)
sess.run(model.reset_ops)
def update_loop():
start = time.time()
print('Update is running')
new_data = []
global data
global val_added
stmp = datetime.now()
val_added += 1
for stk in data:
#frame = pd.read_sql(("SELECT * from {}").format(stk['SYM']), mydb)
rw = utils.update_data(stk)
#print(rw)
new_stk = {
'timestamp': str(stmp),
'SYM': stk['SYM'],
'mean': stk['mean'],
'var': stk['var'],
'Open': rw[0],
'High': rw[1],
'Low': rw[2],
'Curr': rw[3]
}
new_data.append(new_stk)
c.execute(("INSERT INTO {} VALUES ('{}', {}, {}, {}, {})").format(
stk['SYM'], stmp, rw[0], rw[1], rw[2], rw[3]))
mydb.commit()
data = new_data
print('...\nUpdated succesfully!')
async def on_ready():
update_data(data)
logger.info(f"Bot logged as {bot.user.name}")
for guild in bot.guilds:
if str(guild.id) not in data.keys():
data[str(guild.id)] = {"main": None, "channels": {}}
game = discord.Game(f"Manage {len(bot.guilds)} servers")
await bot.change_presence(activity=game)
update_json(data)
# handling the existence of the data.json file
if not os.path.exists('data.json'):
with open('data.json', 'w') as data:
data.write('{}')
def __update_cookies(self):
print("\n")
if "uuid" in self.cookies:
if "ukey" in self.cookies:
print("Qidian cookie expired!")
ukey = input("Enter new ukey: ")
self.cookies["ukey"] = ukey
else:
print("Qidian cookie incomplete!")
self.cookies["ukey"] = input("Enter ukey: ")
elif "ukey" in self.cookies:
print("Qidian cookie incomplete!")
self.cookies["uuid"] = input("Enter uuid: ")
else:
print("Qidian requires a cookie!")
self.cookies["uuid"] = input("Enter uuid: ")
self.cookies["ukey"] = input("Enter ukey: ")
utils.update_data(COOKIES_DATA_KEY, self.cookies)
def test_update_data_entry_2_then_entry_1(self):
utils.update_data(entry = self.entry_2,
vdata = self.vdata,
fdata = self.fdata,
vdata_next_mo = self.vdata_next_mo,
fdata_next_mo = self.fdata_next_mo,
trips = self.trips,
w = self.w,
h = self.h,
n = self.n)
utils.update_data(entry = self.entry_1,
vdata = self.vdata,
fdata = self.fdata,
vdata_next_mo = self.vdata_next_mo,
fdata_next_mo = self.fdata_next_mo,
trips = self.trips,
w = self.w,
h = self.h,
n = self.n)
self.assertEqual(self.vdata[0,0,0,0,0], 123) # pcount at start, t=0
self.assertEqual(self.vdata[0,0,0,0,1], 1) # tcount at start, t=0
self.assertEqual(self.vdata[1,0,0,0,0], 61) # pcount at start, t=1
self.assertEqual(self.vdata[1,0,0,0,1], 1) # tcount at start, t=1
self.assertEqual(self.vdata[0,0,0,1,0], 0) # pcount at end, t=0
self.assertEqual(self.vdata[0,0,0,1,1], 0) # tcount at end, t=0
self.assertEqual(self.vdata[1,0,0,1,0], 184) # pcount at end, t=1
self.assertEqual(self.vdata[1,0,0,1,1], 2) # tcount at end, t=1
self.assertEqual(self.fdata[0,1,0,0,0,0,0], 61) # Trip 1 (dif time slots, 0 to 1, pcount)
self.assertEqual(self.fdata[0,1,0,0,0,0,1], 1) # Trip 1 (dif time slots, 0 to 1, tcoount)
self.assertEqual(self.fdata[1,1,0,0,0,0,0], 123) # Trip 2 (same time slot, t=1, pcount)
self.assertEqual(self.fdata[1,1,0,0,0,0,1], 1) # Trip 2 (same time slot, t=1, pcount)
self.assertEqual(self.trips[0,0,0], 184) # 184 passengers total, both start in and end in Manhattan
self.assertEqual(self.trips[0,0,1], 2) # 2 trips total, both start in and end in Manhattan
self.assertEqual(self.trips[0,1,0], 0) # No trips (or passengers) starting from or ending in Manhattan
self.assertEqual(self.trips[0,1,1], 0)
self.assertEqual(self.trips[1,0,0], 0)
self.assertEqual(self.trips[1,0,1], 0)
self.assertEqual(self.trips[1,1,0], 0)
self.assertEqual(self.trips[1,1,1], 0)
def main():
print("Welcome to BND (Bene's Novel Downloader)")
book = choose_book()
if book is None:
return
utils.update_data("last_book", book)
utils.ensure_config(book)
conf = config.load_config(book)
if conf is None:
return
if conf.name is None:
print("Selected", book)
else:
print("Selected", book, "-", conf.name)
chapters = utils.get_chapters_on_disk(book)
if chapters:
print("Chapters on disk:")
print(utils.format_range_list(utils.group_chapters(chapters)))
else:
print("No chapters on disk")
print()
if utils.input_yes_no("Do you want to download chapters?"):
downloaded_chapters = download_chapters(conf)
if downloaded_chapters is None:
return
print()
if not utils.input_yes_no("Do you also want to convert chapters?"):
print("Ok. Bye.")
return
convert_chapters(conf, *downloaded_chapters)
return
print()
convert_chapters(conf)
def test_update_data_entry_1(self):
utils.update_data(entry = self.entry_1,
vdata = self.vdata,
fdata = self.fdata,
vdata_next_mo = self.vdata_next_mo,
fdata_next_mo = self.fdata_next_mo,
trips = self.trips,
w = self.w,
h = self.h,
n = self.n)
'''
print("\n\nDEBUG\n\n")
print(self.vdata[0:2])
print("####")
print(self.fdata[:,0:2])
print("####")
print(self.trips)
print("\n\nDEBUG\n\n")
import code
code.interact(local=locals())
'''
self.assertEqual(self.vdata[0,0,0,0,0], 123) # pcount at start
self.assertEqual(self.vdata[0,0,0,0,1], 1) # tcount at start
self.assertEqual(self.vdata[1,0,0,1,0], 123) # pcount at end
self.assertEqual(self.vdata[1,0,0,1,1], 1) # tcount at end
self.assertEqual(self.fdata[0,1,0,0,0,0,0], 0) # Dif time slots, so fdata[0] should be all 0s
self.assertEqual(self.fdata[0,1,0,0,0,0,1], 0)
self.assertEqual(self.fdata[1,1,0,0,0,0,0], 123) # Dif time slots, we're looking at the end time (t=1)
self.assertEqual(self.trips[0,0,0], 123)
self.assertEqual(self.trips[0,0,1], 1)
self.assertEqual(self.trips[0,1,0], 0)
self.assertEqual(self.trips[0,1,1], 0)
self.assertEqual(self.trips[1,0,0], 0)
self.assertEqual(self.trips[1,0,1], 0)
self.assertEqual(self.trips[1,1,0], 0)
self.assertEqual(self.trips[1,1,1], 0)
def send_for_params(message):
user = message.from_user.id
params = utils.get_data(user, "params")
filters = utils.get_data(user, "filters").values()
txt_list = ["Посмотрим что у меня для тебя есть", "Дай подумать", "Секундочку", "Уже ищу"]
markup = telebot.types.ReplyKeyboardRemove(selective=True)
bot.send_message(message.chat.id, random.choice(txt_list), reply_markup=markup)
try:
conn = utils.SQLighter(cfg.database)
response_list = conn.select_for_params(**params)
utils.update_data(user, response_list=response_list)
txt = f"""Фильтры: {", ".join(filters)}
{random.choice(answer_list)} '{random.choice(response_list)}'?"""
bot.send_message(message.chat.id, text=txt, reply_markup=inline_keyboard())
except IndexError:
txt = f"""Фильтры: {", ".join(filters)}
С этими фильтрами нет ниодного варианта :(
Попробуй очистить фильтры и начать сначала"""
keyboard = telebot.types.InlineKeyboardMarkup()
clear_filter = telebot.types.InlineKeyboardButton(text="Очистить фильтры", callback_data="clear_filter")
keyboard.add(clear_filter)
bot.send_message(message.chat.id, text=txt, reply_markup=keyboard)
def get_address(element, node):
address = {}
# Build address move to function
for elem in element.iter("tag"):
if elem.attrib['k'].find('addr') != -1 and elem.attrib['k'].count(':') == 1:
address[elem.attrib['k'].replace("addr:", "")] = elem.attrib['v']
elif elem.attrib['k'].count(':') == 0:
node[elem.attrib['k']] = elem.attrib['v']
else:
pass
if address:
if address.has_key('street'):
address['street_better_name'] = update_data(address['street'])
node['address'] = address
if 'city' in address:
address['city_better_name'] = update_city(address['city'])
node['address'] = address
return node
def update(conf):
conf.update({'source': 'stackoverflow', 'doc_type': 'bounties',
'url': URL_TEMPLATE.format(conf['stackoverflow'])})
update_data(conf, get_posts(conf))
def start_trading_bot(client, trade_pairs, kline_size, window_short,
window_long):
#### Initialization ####
DF_dict = {}
positions = {}
for symbol in trade_pairs:
# pull initial dataframes
utils.delete_data(symbol, kline_size)
DF_dict[symbol] = utils.retrieve_data(client,
symbol,
kline_size,
save=True,
start="2021-04-13")
# get information about current investments:
bal = utils.get_currency_balance(client, symbol)
if (float(bal) * float(DF_dict[symbol]["close"].iloc[-1])) > 3:
positions[symbol] = True
else:
positions[symbol] = False
print(positions)
#### Actual bot ####
while True:
log.info(
f'########################### Next Iteration: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")} ########################### '
)
start = time.time()
for symbol in trade_pairs:
log.info(
f"########################### {symbol} ###########################"
)
# update data, try catch the potential api resetting
try:
DF_dict[symbol] = utils.update_data(client,
symbol,
kline_size,
save=True)
except Exception as e:
print(e)
log.info(
f"Data pull error on Binance side, waiting 15 minutes to reconnect"
)
break
# calculating rolling_windows and z-score
DF_dict[symbol] = utils.make_rolling_and_score(
DF_dict[symbol], windows_short[symbol], windows_long[symbol])
print(DF_dict[symbol].tail(5))
current_opportunity = DF_dict[symbol]["score"].iloc[-1]
log.info(f"Z-Score of {symbol}: {current_opportunity}")
# getting account information like balance etc.
try:
bal = utils.get_currency_balance(client, symbol)
except Exception as e:
print(e)
log.info(
f"Data pull error on Binance side, waiting 15 minutes to reconnect"
)
break
log.info(
f'current balance of {symbol.split("EUR")[0]}: {bal}')
# check opportunities and potentially issue an order
if current_opportunity > 0:
if positions[symbol]:
pass
else:
# Actual buy function, handle with care!
order = client.create_order(symbol=symbol,
side=SIDE_BUY,
type=ORDER_TYPE_MARKET,
quoteOrderQty=300)
print(order)
positions[symbol] = True
log.info(
f' market BUY order placed for {symbol} !!!'
)
else:
if positions[symbol]:
# Actual sell function, handle with care!
decimal_place = 15
while decimal_place > -1:
try:
order = client.create_order(symbol=symbol,
side=SIDE_SELL,
type=ORDER_TYPE_MARKET,
quantity=quantity)
break
except:
decimal_place -= 1
quantity = np.round(
float(
client.get_asset_balance(
asset=symbol.split("EUR")[0])["free"]),
decimal_place)
print(order)
positions[symbol] = False
log.info(
f' market SELL order placed for {symbol} !!!'
)
else:
pass
end = time.time()
# sleep for exactly 15 minutes since start
time.sleep(60 * 15 - (end - start) - 1 / 24)
def update(conf):
conf.update({'source': 'github', 'doc_type': 'repositories',
'url': URL_TEMPLATE.format(conf['github'])})
update_data(conf, get_posts(conf))
def select_male_lat(message):
user = message.from_user.id
utils.update_data(user, params={"lang": "lat", "is_male": 1}, filters={"main": "Клички для котов на латиннице"})
txt = "Есть такие категории"
bot.send_message(message.chat.id, txt, reply_markup=main_keyboard_lat())
def update(conf):
conf.update({"source": "reddit", "doc_type": "posts", "url": "http://www.reddit.com/r/{}".format(conf["reddit"])})
update_data(conf, get_posts(conf))
def update(conf):
conf.update({'source': 'google_search', 'doc_type': 'posts'})
update_data(conf, get_posts(conf))
def add_type(message):
user = message.from_user.id
utils.update_data(user, params={"type": f"{message.text}"}, filters={"type": f"{message.text}"})
send_for_params(message)
def select_female_cyr(message):
user = message.from_user.id
utils.update_data(user, params={"lang": "cyr", "is_male": 0}, filters={"main": "Клички для кошек на кирилице"})
txt = "Есть такие категории"
bot.send_message(message.chat.id, txt, reply_markup=main_keyboard_cyr())
def update(conf):
conf.update({'source': 'reddit', 'doc_type': 'posts',
'urls': ['http://www.reddit.com/r/{}'.format(x)
for x in conf['reddit']]})
update_data(conf, get_posts(conf))
def update(conf):
conf.update({'source': 'google_search', 'doc_type': 'posts'})
update_data(conf, get_posts(conf))
def update(conf):
conf.update(CONF)
update_data(conf, get_posts())
def update(conf):
conf.update({'source': 'twitter', 'doc_type': 'posts'})
update_data(conf, get_posts(conf))
