def fill_queue(self):
with self.db_lock:
print("Filling Queue!!!!!")
db = DBConnector()
orders = db.get_all_buy_orders()
for item, number, maxfloat, maxprice in orders:
self.urlq.put(item, timeout=10)
def generateTempResponseMessage(self):
dbconn = DBConnector()
temperatureData = dbconn.getLatestTemperature()
minTemperatureData = dbconn.getMinTemperature()
maxTemperatureData = dbconn.getMaxTemperature()
dateTime = temperatureData[0][0].strftime(
self.const.TEMPERATURE_MESSAGE_DATE_FORMAT)
returnMessage = ''
if len(maxTemperatureData) > 0 and len(minTemperatureData) > 0:
minTime = minTemperatureData[0][0].strftime(
self.const.TEMPERATURE_MESSAGE_MINMAX_DATE_FORMAT)
maxTime = maxTemperatureData[0][0].strftime(
self.const.TEMPERATURE_MESSAGE_MINMAX_DATE_FORMAT)
returnMessage = self.const.TEMPERATURE_MESSAGE % (
dateTime, temperatureData[0][1], minTime,
minTemperatureData[0][1], maxTime, maxTemperatureData[0][1])
else:
returnMessage = self.const.TEMPERATURE_MESSAGE_NOMINMAX % (
dateTime, temperatureData[0][1])
if temperatureData[0][2] is not None and len(
temperatureData[0][2]) > 1:
returnMessage += self.const.TEMPERATURE_MESSAGE_ALERT % temperatureData[
0][2]
returnMessage += self.const.TEMPERATURE_MESSAGE_CLOSURE
return returnMessage
def receive_filtered_listings(self, item_link, price=10 ** 10, wear=10, slowmode=False, maxnum=None):
filtered = []
l_receiver = ListingReceiver(item_link, self.timeouter, self.goclient.client.get_web_session())
if self.goclient.goclient.ready:
listings = l_receiver.get_all_listings(maxnum)
print("found %s entries for item" % len(listings))
inprice = [x for x in listings if x.total_price <= float(price)]
print("%s with correct price" % len(inprice))
for listing in listings:
with self.db_lock:
db = DBConnector()
saved_listing = db.get_listing_by_id(listing.id)
if listing.total_price <= float(price):
if not saved_listing:
iteminfo = self.goclient.get_item_information(listing.return_param_dict())
time.sleep(0.2)
if iteminfo:
floatv = self.goclient.get_float_value(iteminfo)
listing.paintwear = floatv
listing.quality = iteminfo.quality
listing.paintindex = iteminfo.paintindex
db.create_listing(listing)
if listing.paintwear <= float(wear):
# print "Float of this item %s index %s" %(floatv, iteminfo.paintindex)
# print "Price: %s; listing id: %s" %(listing.total_price, listing.id)
filtered.append(listing)
print("%s of them with correct wear" % len(filtered))
return filtered
else:
print("CSGO not ready")
print("Client %s logged in %s" % (str(self.goclient.client), self.goclient.client.logged_on))
self.goclient._connect_go()
return filtered
def retrieveTemperatureData(self):
temperatureData = requests.get(
self.config.DATA_KNMI_JSON_LOCATION).json()
db = DBConnector()
alerttext = ''
if temperatureData['liveweer'][0]['alarm'] == 1:
alerttext = temperatureData['liveweer'][0]['alarmtxt']
db.insertTemperatureLog(datetime.now(),
temperatureData['liveweer'][0]['temp'],
alerttext)
def fillDB(self, covidArray):
logging.info(
'Start the DB connector and add the results to the database')
# start the database connector
db = DBConnector()
# Push it all to database.
for infectionDate in covidArray:
db.updateDailyInfected(infectionDate, covidArray[infectionDate][0],
covidArray[infectionDate][1],
covidArray[infectionDate][2])
def run(self):
while not self.stopped.wait(10):
with self.client.db_lock:
db = DBConnector()
buyorders = db.get_all_buy_orders()
print("Buyorders fetched")
for item, number, maxfloat, maxprice in buyorders:
if number >= 1:
listings = db.get_listing_for_url(item)
fitting = [x for x in listings if
x.total_price <= float(maxprice) and x.paintwear <= float(maxfloat)]
for item in fitting:
print("BUYING ITEM!!!!!!!!!!!!!!!")
saved = db.save_bought_item(item, maxfloat)
if not saved:
print("COULD NOT BE SAVED!!!")
def download_pvlive_from_db(self, version):
"""Download the pvgeneration data from ssfdb3"""
with DBConnector(mysql_defaults=self.
config["mysql_options_readwrite_nationalgrid"],
session_tz="UTC") as dbc:
sql_template = (
"SELECT UNIX_TIMESTAMP(`datetime_GMT`), `generation_MW`, `capacity_MWp`,"
"`site_count` from {} WHERE `version_id` = {} and `datetime_GMT` > "
"'{}' and `datetime_GMT` < '{}';")
sql = sql_template.format(
self.config["pvgen_table"], version,
datetime.strftime(self.options.start, "%Y-%m-%d"),
datetime.strftime(self.options.end, "%Y-%m-%d"))
# import pdb; pdb.set_trace()
data = dbc.query(sql)
df = pd.DataFrame(data,
columns=[
"utc timestamp", "generation MW", "capacity MWp",
"site count"
])
df.index = pd.DatetimeIndex(pd.to_datetime(df["utc timestamp"],
utc=True,
unit="s"),
tz="UTC")
return df
def __init__(self):
self.__disable = False
self.__is_intelligent = False
self._vk_session = vk_api.VkApi(
BOT_SIGN_IN['login'],
BOT_SIGN_IN['password'],
captcha_handler=self.__captcha_handler
)
try:
self._vk_session.authorization()
except vk_api.AuthorizationError as error_msg:
print(error_msg)
return
self._logger = Logger()
self._db = DBConnector()
self._news = NewsParser()
self._math = BotMath()
self._vk = self._vk_session.get_api()
self._ignore_msgs = self._logger.read_history()
self._bot_name = self._get_user_name(None)
self.__ans_list = []
self.__msg_list = []
self.__intell__ans_list = []
self.__intell__msg_list = []
self.__update_messages()
def __init__(self, logger):
self._logger = logger
self._logger.info('Initting matchmaking')
self._db_name = 'matchmaking'
self._collection_name = 'match_queue'
self._db_conn = DBConnector(self._db_name, self._collection_name)
self._allowed_platforms = 'pc', 'ps4', 'xb', 'any'
def __init__(self, **kwargs):
DBConnector.__init__(self, kwargs['Path'], len(kwargs['Password']) != 0)
self.name = kwargs['Name']
self.type = kwargs['Type']
self.path = kwargs['Path']
# According to the AES128 password length must be 16
if len(kwargs['Password']) != 0:
key = kwargs['Password']
if len(key) > 16:
key = key[:16]
if len(key) < 16:
i = 0
while len(key) < 16:
key = key + key[i]
i = i + 1
self.password = key
def download_passiv_systems(self):
with DBConnector(mysql_defaults=self.mysql_defaults,
session_tz="UTC") as dbc:
sql = "SELECT `latitude`, `longitude`, `kWp` " \
"FROM pvstream.view_system_params_grouped_op_at;"
data = dbc.query(sql, df=True)
self.data = data
return data
def __init__(self, **kwargs):
DBConnector.__init__(self, kwargs['Path'],
len(kwargs['Password']) != 0)
self.name = kwargs['Name']
self.type = kwargs['Type']
self.path = kwargs['Path']
# According to the AES128 password length must be 16
if len(kwargs['Password']) != 0:
key = kwargs['Password']
if len(key) > 16:
key = key[:16]
if len(key) < 16:
i = 0
while len(key) < 16:
key = key + key[i]
i = i + 1
self.password = key
def test_count_in_DB(self, table, mysql_options_file, data):
SL_count = len(data)
sql = f"SELECT count(*) FROM `{table}`;"
with DBConnector(mysql_options_file, session_tz="UTC") as dbc:
DB_count = dbc.query(sql)
if int(DB_count[0][0]) != int(SL_count):
import pdb
pdb.set_trace()
raise Exception("Wrong number of rows inserted into DB...")
def createGraph(self):
db = DBConnector()
temperatureData = db.getTemperatureGraphData()
x = [] # times
y = [] # temps
for i in range(len(temperatureData) - 1, -1, -1):
x.append(temperatureData[i][0].strftime(
self.const.TEMPERATURE_GRAPH_DATE_FORMAT))
y.append(temperatureData[i][1])
figure(num=None,
figsize=(16, 9),
dpi=100,
facecolor='w',
edgecolor='k')
plt.plot(x, y)
plt.xlabel("Time")
plt.ylabel("Temperature")
plt.title('Temperature over time')
logging.info('Save historic data graph for temperature')
plt.savefig(self.const.TEMPERATURE_GRAPH_FILENAME)
def work_info_q(self):
while not self.listingq.empty():
listing = self.listingq.get(True, 10)
# print("Input Listing %s"%listing)
with self.db_lock:
db = DBConnector()
saved_listing = db.get_listing_by_id(listing.id)
# print("Listing in work %s"%listing)
if not saved_listing:
# print(listing.return_param_dict())
iteminfo = self.goclient.get_item_information(listing.return_param_dict())
# time.sleep(0.2)
if iteminfo:
floatv = self.goclient.get_float_value(iteminfo)
print("Float value aquired %s" % floatv)
listing.paintwear = floatv
listing.quality = iteminfo.quality
listing.paintindex = iteminfo.paintindex
db.create_listing(listing)
self.listingqfull.put(listing, True, 10)
else:
pass
def upload_to_db(self, data, table, mysql_options_file):
# data = [row if for row in data]
# import pdb; pdb.set_trace()
print("\nUploading to database...\n")
if type(data) is not list:
raise ValueError("Data to upload must be list of lists...")
sql = f"INSERT INTO `{table}` (`gen_id`, `latitude`, `longitude`, " \
f"`latitude_rounded`, `longitude_rounded`, `installdate`, " \
f"`installedcapacity`) VALUES (%s,%s,%s,%s,%s,%s,%s)" \
f"ON DUPLICATE KEY UPDATE " \
f"`latitude` = VALUES(`longitude`)," \
f"longitude = VALUES(`longitude`)," \
f"`installedcapacity` = VALUES(`installedcapacity`);"
with DBConnector(mysql_options_file, session_tz="UTC") as dbc:
dbc.iud_query(sql, data)
print("\t--> done.")
def run_query(database, query):
"""
runs query from variable with sql code
:param database: target database
:param query: variable with sql code
:return: returns a table if it exists
"""
with DBConnector(db_name=database) as conn:
cursor = conn.cursor()
cursor.execute(query)
cursor.commit()
try:
results = cursor.fetchall()
return results
except pyodbc.ProgrammingError:
pass
finally:
cursor.close()
def get_deals(self):
with open(self.conffile, "r") as file:
db = DBConnector()
with self.db_lock:
lines = file.readlines()
for line in lines[1:]:
url, number, maxfloat, maxprice, buygrp, dealno, dealname = line.split(";")
url = url.replace(" ", "")
print("%s %s,%s,%s,%s" % (lines.index(line), url.replace(" ", ""), number, maxfloat, maxprice))
deal_dict = db.get_deals_as_dict()
if not self._is_contained({'url': url,
'price': maxprice,
'float': maxfloat,
'grp': buygrp,
'dealname': dealname}, deal_dict):
print(db.create_deal(dealname))
deal = db.get_deal_by_name(dealname)
print(deal)
db.create_deal_grp(buygrp, number, maxfloat, deal['id'], maxprice)
db.create_buy_order(url, buygrp, deal['id'])
def run_query_from_file(database, path_to_file):
"""
runs query from *.sql file
:param database: target database
:param path_to_file: path to file with sql query
:return: returns a table if it exists
"""
with DBConnector(db_name=database) as conn:
cursor = conn.cursor()
file = open(path_to_file, 'r')
sql = " ".join(file.readlines())
file.close()
cursor.execute(sql)
cursor.commit()
try:
results = cursor.fetchall()
return results
except pyodbc.ProgrammingError:
pass
finally:
cursor.close()
class QueueProcessor():
def __init__(self):
l.debug("Worker spawned")
self.db = DBConnector()
def _conPrint(self, ev):
buf = "[{}] {}({}:{}): {}".format(ev.hex_addr, ev.function, ev.pid,
ev.tid, ev.payload)
l.conPrint(buf, ev.event_time)
def _fileLog(self, ev):
l.fileLog(ev.pid, ev.function, ev.payload, ev.event_time)
def Work(self):
while True:
ev = eq.get()
self._conPrint(ev)
self._fileLog(ev)
self.db.ProcessHook(ev)
sp.addHookedFunc(ev.function, ev.pid, ev.tid) # send the whole ev
eq.task_done()
def __init__(self):
self.address = '10.51.50.1'
self.port = 8089
self.loop = asyncio.get_event_loop()
self.db_connector = DBConnector()
@author: User
"""
from dbconnector import DBConnector
import os
def parse_date(date):
date = date.split("-")
return "{:04d}-{:02d}-{:02d}".format(int(date[0]), int(date[1]),
int(date[2]))
con = DBConnector(user='******', \
password='******', \
host='localhost')
con.connect()
for (dirpath, dirnames, filenames) in os.walk('..\\ToAdd'):
for f in filenames:
if (os.path.getsize(os.path.join(dirpath, f)) > 10000 and '.csv' in f):
print('---')
fields = f.split('_')
if (len(fields) == 2):
label = fields[0]
def __init__(self):
l.debug("Worker spawned")
self.db = DBConnector()
def getCovidDataForDate(self, compareDate):
dateStr = compareDate.strftime(self.const.DATA_DATE_FORMAT)
dbconn = DBConnector()
return dbconn.getDailyInfected(dateStr)
"""
import os
import logging
from dbconnector import DBConnector
if __name__ == "__main__":
# Set our preferred logging format
fmt = "%(asctime)s %(module)s %(levelname)s %(message)s"
logging.basicConfig(format=fmt, level=os.environ.get("LOGLEVEL", "DEBUG"))
# Connect by passing an options file (recommended)
options_file = "example_db_options.secret"
with DBConnector(connector_args={"option_files": options_file},
cnx_retries=3) as dbc:
test = dbc.query("select testcol1, testcol2 from test limit 10;")
print(test)
test = dbc.query("select testcol1, testcol2 from test limit 10;",
df=True)
print(test)
test = dbc.query("select * from test limit 10;")
print(test)
test = dbc.iud_query("insert into test (testcol2) VALUES (%s);",
data=[
[
"hello",
],
])
print(test)
test = dbc.proc(proc="test_procedure", proc_args=[12345])
import json
from flask import request
from dbconnector import DBConnector
from flask_restful import Resource
from settings import (DB_HOST, DB_PORT, DB_USER, DB_PASSWORD)
db_inst = DBConnector(host=DB_HOST,
username=DB_USER,
password=DB_PASSWORD,
port=DB_PORT)
class ProductList(Resource):
def get(self):
json_data = request.get_json(force=True)
# category, brand, source, subcategory, title
conditions = []
for key, value in json_data.items():
conditions.append("{key}='{value}'".format(key=key, value=value))
if conditions:
conditions = 'WHERE {cond}'.format(cond=" AND ".join(conditions))
query = "SELECT sku,title,thumbnail,mrp,discount,stock FROM " \
"dataweave_india.products {condition};".format(condition=conditions)
result = db_inst.select_query_dict(query=query)
return {'status': 'success', 'data': json.dumps(result)}, 200
class MainBot(object):
def __init__(self):
self.__disable = False
self.__is_intelligent = False
self._vk_session = vk_api.VkApi(
BOT_SIGN_IN['login'],
BOT_SIGN_IN['password'],
captcha_handler=self.__captcha_handler
)
try:
self._vk_session.authorization()
except vk_api.AuthorizationError as error_msg:
print(error_msg)
return
self._logger = Logger()
self._db = DBConnector()
self._news = NewsParser()
self._math = BotMath()
self._vk = self._vk_session.get_api()
self._ignore_msgs = self._logger.read_history()
self._bot_name = self._get_user_name(None)
self.__ans_list = []
self.__msg_list = []
self.__intell__ans_list = []
self.__intell__msg_list = []
self.__update_messages()
def __update_messages(self):
u"""
Метод используемый для обновления списков с айдишниками сообщений.
Используется после добавления/удаления нового сообщения.
"""
self.__ans_list = self._db.select_ids(is_question_answer=True)
self.__msg_list = self._db.select_ids()
self.__intell__ans_list = self._db.select_ids(is_question_answer=True, is_intelligent=True)
self.__intell__msg_list = self._db.select_ids(is_intelligent=True)
@staticmethod
def __captcha_handler(captcha):
u"""
При возникновении капчи вызывается эта функция и ей передается объект
капчи. Через метод get_url можно получить ссылку на изображение.
Через метод try_again можно попытаться отправить запрос с кодом капчи
"""
key = input("Enter Captcha {0}: ".format(captcha.get_url())).strip()
# Пробуем снова отправить запрос с капчей
return captcha.try_again(key)
def _add_msg_to_ignore(self, msg):
u"""
Добавляем в логгер сообщения, адресованные боту.
Эти сообщения будут проигнорированы.
"""
if 'chat_id' in msg:
self._ignore_msgs.append('%s-%s-%s' % (msg['chat_id'], msg['id'], msg['user_id']))
else:
self._ignore_msgs.append('NONE-%s-%s' % (msg['id'], msg['user_id']))
self._logger.write_history(self._ignore_msgs)
def _is_msg_in_ignore(self, msg):
u"""
Проверяем есть ли сообщение в логгере.
Если есть, то игнорим его.
"""
# result = False
if 'chat_id' in msg:
result = '%s-%s-%s' % (msg['chat_id'], msg['id'], msg['user_id']) in self._ignore_msgs
else:
result = 'NONE-%s-%s' % (msg['id'], msg['user_id']) in self._ignore_msgs
return result
def _send(self, msg, text):
u"""
Метод отправки собщения с текстом text.
"""
if 'chat_id' in msg:
self._vk.messages.send(
chat_id=msg['chat_id'],
message=text
)
else:
self._vk.messages.send(
user_id=msg['user_id'],
message=text
)
def _get_random_message(self, msg_list):
u"""
Получаем рандомное сообщение из списка айдишников сообщений.
"""
return self._db.get_message(random.choice(msg_list))
def _send_message_from_db(self, msg):
u"""
Метод отправляющий сообщение в чат с БД.
"""
if '?' in msg['body']:
text = self._get_random_message(self.__ans_list) if not self.__is_intelligent \
else self._get_random_message(self.__intell__ans_list)
else:
text = self._get_random_message(self.__msg_list) if not self.__is_intelligent \
else self._get_random_message(self.__intell__msg_list)
self._send(msg, u'%s, %s' % (self._get_user_name(msg['user_id']), text))
@staticmethod
def _prepare_msg(msg):
u"""
Метод, используемый для подготовки сообщений для записи их в БД.
Добавляет к спец. символам сообщения дополнительный слеш, с целью не потерять труктуру сообщения.
"""
return msg.replace('\'', '\\\'')
def _remember_new_data(self, msg):
u"""
Запись нового сообщения в БД, обновляем списки айдишников сообщений.
"""
self._db.add_new_row(
msg['user_id'],
self._prepare_msg(msg['body'][len(self._bot_name) + 9:]),
is_intelligent=self.__is_intelligent
)
user_name = self._get_user_name(msg['user_id'])
text = self._prepare_msg(msg['body'][len(self._bot_name) + 9:])
self._send(
msg,
LITERALS['remember_data'].replace('{user_name}', user_name).replace('{message}', text)
)
print(u'Remember new data: from %s, msg: %s' % (msg['user_id'], text))
self.__update_messages()
def _forget_data(self, msg):
u"""
Помечаем сообщение как удаленое, обновляем списки айдишников сообщений.
"""
self._db.del_row(self._prepare_msg(msg['body'][len(self._bot_name) + 8:]))
user_name = self._get_user_name(msg['user_id'])
text = self._prepare_msg(msg['body'][len(self._bot_name) + 9:])
self._send(
msg,
LITERALS['forget_data'].replace('{user_name}', user_name).replace('{message}', text)
)
print(u'Remove data: from %s, msg: %s' % (msg['user_id'], text))
# self.__ans_list = self._db.select_ids()
self.__update_messages()
def _get_help(self):
u"""
Вывод справки по боту.
"""
return u"""
Моя текущая версия: version
Список моих команд на сегодня:
* Выучить что-то новое: name запомни <предложение/фраза>
* Выдать вероятность события: name инфа <фраза/название/событие>
* Выбирает случайного участника беседы: name кто <предложение/фраза>
* Сменить режим общения бота: name смени режим
* Получить текущий режим бота: name режим
* Получить список новостей: name новости
* Посчитать пример: name м
* Справка по математике: name м помощь
* Получить ТВ-программу на ближайшее время: name телепрограмма
* Просто попиздеть: name <предложение/фраза>
* [Для админов] Забыть что-то старое: name забудь <предложение/фраза>
* [Для админов] Выключить бота: name завали ебало
* [Для админов] Включить бота : name камбекнись
Список разработчиков:
* Илья - http://vk.com/id96996256
Список админов:
* Илья - http://vk.com/id96996256
* Дмитрий - http://vk.com/id77698338
""".replace('name', self._bot_name).replace('version', VERSION)
def _get_bot_id(self):
u"""
Получаем айди вк бота.
"""
return int(self._vk_session.token['user_id'])
def _get_user_name(self, user_id):
u"""
Получаем имя пользователя по его айди.
"""
return u'%s' % self._vk.users.get(user_ids=[user_id])[0]['first_name']
def _get_user_lastname(self, user_id):
u"""
Получаем фамилию пользователя по его айди.
"""
return u'%s' % self._vk.users.get(user_ids=[user_id])[0]['last_name']
def _get_chat_users_ids(self, chat_id):
u"""
Получаем список пользователей чата по айдишнику чата.
"""
users = self._vk.messages.getChatUsers(chat_id=chat_id)
users.remove(self._get_bot_id())
idx = random.randint(0, len(users) - 1)
return u'%s %s' % (self._get_user_name(users[idx]), self._get_user_lastname(users[idx]))
def __command_bot_off(self, msg):
u"""
Команда приостановления дейтельности бота.
"""
if msg['body'][:len(self._bot_name) + 13] == LITERALS['commands']['bot_off']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
user_name = self._get_user_name(msg['user_id'])
self._send(msg, LITERALS['commands']['bot_off']['answer'].replace('{user_name}', user_name))
self.__disable = True
return True
return False
def __command_bot_on(self, msg):
u"""
Команда возобновления дейтельности бота.
"""
if msg['body'][:len(self._bot_name) + 13] == LITERALS['commands']['bot_on']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
user_name = self._get_user_name(msg['user_id'])
self._send(msg, LITERALS['commands']['bot_on']['answer'].replace('{user_name}', user_name))
self.__disable = False
return True
return False
def __command_bot_help(self, msg):
u"""
Команда получения справки.
"""
if msg['body'][:len(self._bot_name) + 8] == LITERALS['commands']['help']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._send(msg, '%s, %s' % (self._get_user_name(msg['user_id']), self._get_help()))
return True
return False
def __command_bot_forget(self, msg):
u"""
Команда "удаления" сообщения бота.
"""
if msg['body'][:len(self._bot_name) + 8] == LITERALS['commands']['forget']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._forget_data(msg)
return True
return False
def __command_bot_remember(self, msg):
u"""
Команда, для запоминания сообщения.
"""
if msg['body'][:len(self._bot_name) + 9] == LITERALS['commands']['remember']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._remember_new_data(msg)
return True
return False
def __command_bot_probability(self, msg):
u"""
Команда получения процента.
"""
if msg['body'][:len(self._bot_name) + 6] == LITERALS['commands']['probability']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
probability = random.randint(0, 100)
if probability == 100:
text = LITERALS['commands']['probability']['answer']['max'].replace('{percent}', str(probability))
elif probability > 75:
text = LITERALS['commands']['probability']['answer']['high'].replace('{percent}', str(probability))
elif probability == 0:
text = LITERALS['commands']['probability']['answer']['min'].replace('{percent}', str(probability))
elif probability < 15:
text = LITERALS['commands']['probability']['answer']['low'].replace('{percent}', str(probability))
else:
text = LITERALS['commands']['probability']['answer']['mid'].replace('{percent}', str(probability))
self._send(msg, u'%s, %s' % (self._get_user_name(msg['user_id']), text))
return True
return False
def __command_bot_message(self, msg):
u"""
Команда отправки ботом сообщения.
"""
if msg['body'][:len(self._bot_name)] == self._bot_name \
and not self._is_msg_in_ignore(msg) and len(msg['body']) > 5:
self._add_msg_to_ignore(msg)
self._send_message_from_db(msg)
return True
return False
def __command_bot_change_mod(self, msg):
u"""
Команда смены режима общения бота.
"""
if msg['body'][:len(self._bot_name) + 12] == LITERALS['commands']['change_mod']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self.__is_intelligent = not self.__is_intelligent
user_name = self._get_user_name(msg['user_id'])
if self.__is_intelligent:
text = LITERALS['commands']['change_mod']['answer']['intelligency'].replace('{user_name}', user_name)
else:
text = LITERALS['commands']['change_mod']['answer']['default'].replace('{user_name}', user_name)
self._send(msg, text)
return True
return False
def __command_bot_current_mod(self, msg):
u"""
Команда получения текущего режима общения.
"""
if msg['body'][:len(self._bot_name) + 6] == LITERALS['commands']['current_mod']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
user_name = self._get_user_name(msg['user_id'])
if self.__is_intelligent:
text = LITERALS['commands']['current_mod']['answer']['intelligency'].replace('{user_name}', user_name)
else:
text = LITERALS['commands']['current_mod']['answer']['default'].replace('{user_name}', user_name)
self._send(msg, text)
return True
return False
def __command_bot_news(self, msg):
u"""
Команда получения актуальных новостей по РФ и СПб с сайта http://yandex.ru.
"""
if msg['body'][:len(self._bot_name) + 8] == LITERALS['commands']['news']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._send(msg, u'%s,\n%s' % (self._get_user_name(msg['user_id']), self._news.get_news()))
return True
return False
def __command_bot_tv_list(self, msg):
u"""
Команда получения актуальной телепрограммы с сайта http://yandex.ru.
"""
if msg['body'][:len(self._bot_name) + 14] == LITERALS['commands']['tv_list']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._send(msg, u'%s,\n%s' % (self._get_user_name(msg['user_id']), self._news.get_tv_list()))
return True
return False
def __command_bot_math(self, msg):
u"""
Команда для вычисления математических выражений.
"""
if msg['body'][:len(self._bot_name) + 9] == LITERALS['commands']['math']['cmd']['help']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
user_name = self._get_user_name(msg['user_id'])
help_text = self._math.get_help()
self._send(
msg,
LITERALS['commands']['math']['answer'].replace('{user_name}', user_name).replace('{help}', help_text)
)
return True
if msg['body'][:len(self._bot_name) + 3] == LITERALS['commands']['math']['cmd']['calc']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
self._send(msg, u'%s, %s' % (
self._get_user_name(msg['user_id']),
self._math.calculate(msg['body'][len(self._bot_name) + 3:])
))
return True
return False
def __command_bot_who_is(self, msg):
u"""
Команда вывода ответа на вопрос "кто ...?"
"""
if 'chat_id' in msg:
if msg['body'][:len(self._bot_name) + 4] == LITERALS['commands']['who_is']['cmd']\
.replace('{bot_name}', self._bot_name):
self._add_msg_to_ignore(msg)
user_name = self._get_chat_users_ids(msg['chat_id'])
answer = LITERALS['commands']['who_is']['answer']
self._send(msg, u'%s, %s' % (
self._get_user_name(msg['user_id']),
answer[random.randint(0, len(answer) - 1)].replace('{user_name}', user_name)
))
return True
return False
def __analyze_messages(self, msg_list=None):
u"""
Основной метод анализа входящих сообщений.
Бот анализирует только те сообщения, которые адресованы именно ему.
Анализ идет исходя из правил русского языка: "ИмяБота[,] текст сообщения"
"""
if msg_list:
for msg in msg_list:
if not self._is_msg_in_ignore(msg):
if not self.__disable:
if msg['user_id'] in ADMIN_LIST:
self.__command_bot_off(msg)
self.__command_bot_forget(msg)
self.__command_bot_help(msg)
self.__command_bot_remember(msg)
self.__command_bot_probability(msg)
self.__command_bot_change_mod(msg)
self.__command_bot_current_mod(msg)
self.__command_bot_news(msg)
self.__command_bot_tv_list(msg)
self.__command_bot_math(msg)
self.__command_bot_who_is(msg)
# априори последняя команда, иначе все что после выполнено не будет.
self.__command_bot_message(msg)
else:
if msg['user_id'] in ADMIN_LIST:
self.__command_bot_on(msg)
def __main(self):
u"""
Основной метод бота для работы.
Читает первые 5 входящих сообщений.
"""
while True:
self.__analyze_messages(self._vk.messages.get(count=5)['items'])
# current_chat_title = vk.messages.getChat(chat_id=target_chat_id)['title']
# if current_chat_title != target_chat_title:
# print('Changed:', current_chat_title, 'to', target_chat_title)
# vk.messages.editChat(chat_id=target_chat_id, title=target_chat_title)
time.sleep(2)
def start_bot(self, debug=False):
u"""
Метод, запускающий бота.
"""
print(u"Starting work...")
while True:
if debug:
self.__main()
else:
try:
self.__main()
except Exception as error_msg:
print('Oops! I\'m restarting. Error: %s' % error_msg)
from winappdbg import Debug
from ev_tracer import TracingEventHandler
from art import banner
from uuid import uuid4
from logger import Logger
from helper import *
from storagepool import sp
from reporter import Reporter
from target import Target
from threading import Thread
from queueprocessor import QueueProcessor
from dbconnector import DBConnector
EH = TracingEventHandler()
r = Reporter()
db = DBConnector()
machine_id = str()
def keyboardInt():
l.warn("Keyboard interrupt. Cleaning up.")
def _resolvePid(pid):
proc_name = debug.system.get_process(pid).get_filename()
return proc_name.split('\\')[-1]
def attachToFilename(filename):
try:
def fetch_listings_for_deals(self):
with self.db_lock:
db = DBConnector()
orders = db.get_all_buy_orders()
for item, number, maxfloat, maxprice in orders:
print(self.receive_filtered_listings(item, maxprice, maxfloat, maxnum=100))
# This script is meant to be executed once to create the tables in the database.
# It creates the table, at this moment, no data is persistent so this script can easily be
# re-run without any issues, just run refreshCovidData.py after it.
# @author Niels Dimmers
import mysql.connector
from dbconnector import DBConnector
from config import Config
config = Config()
# load the DB Connector to execute the creates
db = DBConnector()
# *** TABLES CONTAINING DATA WHICH IS REFRESHED EACH TIME, AND THEREFORE CAN BE DROPPED SAFELY ***
TABLES = {}
TABLES['dailyInfected'] = ("CREATE TABLE `dailyInfected` ("
" `infected` int(11) NOT NULL,"
" `hospitalised` int(11) DEFAULT 0 NOT NULL,"
" `deceased` int(11) DEFAULT 0 NOT NULL,"
" `date` date NOT NULL,"
" PRIMARY KEY (`date`)"
") ENGINE=InnoDB")
# Loop over the array
for table_name in TABLES:
table_description = TABLES[table_name]
print("Dropping table %s if it exists" % format(table_name))
db.executeQuery('DROP TABLE IF EXISTS %s' % str(table_name))
print("Creating table %s " % format(table_name))
'round': rnd,
'local': teams[0],
'visitant': teams[1],
'date': time
})
round_info = pd.DataFrame(games_list)
return round_info
# ==========================================================================
# Params and definitions
# ==========================================================================
db_object = DBConnector(data_base='laliga_scraping', table='calendar')
scraper = Scraper(url='https://resultados.as.com/resultados/futbol/primera/{season}/jornada/regular_a_{rnd}')
# ==========================================================================
# Code
# ==========================================================================
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--season", help="Season to extract the data", default='2018_2019')
args = parser.parse_args()
print 'Scrapig calendar session %s' % args.season
