def __init__(self, token):
super(NyetBot, self).__init__(token)
self.commands = {
'/add_meme': self.add_meme_init,
'/del_meme': self.del_meme_init,
'/show_memes': self.show_memes,
'/discard': self.discard
}
self.average_message_per_fuck = 300
self.f***s = [
'pishov nahui', 'ssaniy loh', 'eto nepravda', 'dvachuiu',
'nyet ty', 'eto pravda', 'on sharit', 'rolidoviy',
'kaka stelit vniz po noge, ege-ge', 'ok, boomer'
]
self.repost_fucks = [
"eto je boyan, petushara", "REEEEEE \n POOOOOST",
"ya eto uje videl, nesi novoe", "davay chto posvejee, valet",
"boyan-huiyan"
]
self.redis_connection = RedisConnection(connection_string)
self.memes = self.redis_connection.get_all_memes()
self.images = self.redis_connection.get_images_tree()
self.users_waiting_del = set([])
self.user_memes = {}
self.user_meme_struct = {'meme_name': None, "meme_pic": None}
self.meme_meta_struct = {'type': None, "adress": None}
self.response_types = set(['text', 'photo'])
def __init__(self, token):
super(NyetBot, self).__init__(token)
self.commands = {
'/add_meme': self.add_meme_init,
'/del_meme': self.del_meme_init,
'/show_memes': self.show_memes,
'/discard': self.discard
}
self.average_message_per_fuck = 300
self.f***s = [
'slava Ukraine!', 'nu eto Zalupa uje', 'da', 'tak tochno',
'eto ne tak', 'infa 100', 'nyet', 'podderjivau vot etogo',
'puk puk', 'welcome to the club, buddy'
]
self.repost_fucks = [
"eto je boyan, petushara", "REEEEEE \n POOOOOST",
"ya eto uje videl, nesi novoe", "davay chto posvejee, valet",
"boyan-huiyan"
]
self.redis_connection = RedisConnection(connection_string)
self.memes = self.redis_connection.get_all_memes()
self.images = self.redis_connection.get_images_tree()
self.users_waiting_del = set([])
self.user_memes = {}
self.user_meme_struct = {'meme_name': None, "meme_pic": None}
self.meme_meta_struct = {'type': None, "adress": None}
self.response_types = set(['text', 'photo'])
class GraphiteCacher(object):
"""
Class connecting Redis and graphite-api
"""
def __init__(self, target_metric):
"""
Constructor
"""
self.target_metric = target_metric
self.fetcher = GraphiteFetcher()
self.redis = RedisConnection()
self.timestamp = int(round(time.time()))
self.config = ConfigParser.RawConfigParser()
self.config.read('/etc/kujira-graphite.cfg')
def get_metric_and_push_to_redis(self):
"""Get metric from GraphiteFetcher and push to redis"""
how_old_fetch_from_start = self.config.get('Metrics', 'how_old')
data = self.fetcher.get_data_json(self.target_metric, how_old_fetch_from_start)
redis_metrics = self.redis.get_metric(self.target_metric)
if redis_metrics is None:
d_string = str(data[0]['datapoints'][0])
self.redis.append_metric(data[0]['target'], d_string)
self.timestamp = data[0]['datapoints'][1]
for index, d in enumerate(data[0]['datapoints']):
if d[0] is not None and index != 0:
d_string = str(d)
self.redis.append_metric(data[0]['target'], ", " + d_string)
self.timestamp = d[1]
return data
def get_metric_and_append_to_redis(self):
"""Get metric from GraphiteFetcher and append to redis"""
data = self.fetcher.get_data_json(self.target_metric, '-' + str(self.get_time_diff()) + 's')
for d in data[0]['datapoints']:
if d[0] is not None and d[1] > self.timestamp:
d_string = str(d)
self.redis.append_metric(data[0]['target'], ", " + d_string)
self.timestamp = d[1]
return data
def get_time_diff(self):
"""Get time difference between current time and timestamp"""
current_time = int(round(time.time())) + 15
return current_time - self.timestamp
def delete_metric_from_redis(self):
"""Remove metric from Redis"""
self.redis.delete_metric(self.target_metric)
def __init__(self, target_metric):
"""
Constructor
"""
self.target_metric = target_metric
self.fetcher = GraphiteFetcher()
self.redis = RedisConnection()
self.timestamp = int(round(time.time()))
self.config = ConfigParser.RawConfigParser()
self.config.read('/etc/kujira-graphite.cfg')
def conn_redis(self):
"""
#先连接目标redis服务器，再跟进情况判断是否要连接源redis服务器
:return:
"""
if self.drconn:
self.pushButton_conn.setText("connection")
self.pushButton_getdata.setEnabled(False)
self.drconn.connection_pool.disconnect()
self.drconn = None
if self.srconn:
self.srconn.connection_pool.disconnect()
self.srconn = None
return
###set destination redis arg
dhost = self.lineEdit_destination_host.text()
if not dhost:
return
dport = self.lineEdit_destination_port.text()
if not dport:
return
else:
dport = int(dport)
dauth = self.lineEdit_destination_auth.text()
dragr = {"host": dhost, "port": dport, "password": dauth}
rcb = RedisConnection(self)
###get destination conn
self.drconn = rcb.get_conn(dragr)
if self.drconn:
# msg = "Connecting to redis was successful:%s\n"%(dragr)
# self.show_msg(msg)
if self.s_type == "server":
self.conn_source_redis(rcb)
else:
self.pushButton_conn.setText("disconnection")
self.pushButton_getdata.setEnabled(True)
def conn_redis_dst(self):
"""
#先连接目标redis服务器，再跟进情况判断是否要连接源redis服务器
:return:
"""
if self.rconn_dst:
self.pushButton_conn.setText("connection")
self.rconn_dst.connection_pool.disconnect()
self.rconn_dst = None
if self.rconn_src:
self.rconn_src.connection_pool.disconnect()
self.rconn_src = None
return
###set destination redis arg
dhost = self.lineEdit_destination_host.text()
if not dhost:
return
dport = self.lineEdit_destination_port.text()
if not dport:
return
else:
dport = int(dport)
dauth = self.lineEdit_destination_auth.text()
drag = {"host": dhost, "port": dport, "password": dauth}
rcb = RedisConnection(self)
###get destination conn
self.rconn_dst = rcb.get_conn(drag)
if self.rconn_dst:
if self.s_type == "server":
self.conn_redis_src(rcb)
else:
self.pushButton_conn.setText("disconnection")
self.pushButton_sync.setEnabled(True)
def main():
#print 'memory used: ', psutil.Process(os.getpid()).memory_info().rss
redis_instance = RedisConnection(ReadConfiguration.redis_port,
ReadConfiguration.redis_host,
ReadConfiguration.redis_db)
table = Table()
SetArp(redis_instance.redis_connection, table)
buffer = {}
app_thread = AppLogThread(1, "App-Thread", ReadConfiguration.app_log_num,
table, buffer)
file_thread = FileLogThread(2, "File-Thread",
ReadConfiguration.download_log_num,
ReadConfiguration.upload_log_num, table,
buffer)
login_thread = LoginLogThread(3, "Login-Thread",
ReadConfiguration.login_log_num, table,
buffer)
app_thread.start()
file_thread.start()
login_thread.start()
def avg_humidity(self, duration):
recent_humidity = self.conn.retrieve(duration)
return sum(recent_humidity)/len(recent_humidity)
def make_graph(self):
leds = zeros([8, 8, 3], dtype=int)
humidity = self.avg_humidity(10)
for i, colour in enumerate(self.colours):
if humidity > i * self.step:
leds[7-i, :, :] = colour
return reshape(leds, [64, 3])
def show_humidity(self, event):
if event.action == ACTION_PRESSED:
humidity = round(self.avg_humidity(10))
self.display.show_message(f"{humidity}%")
self.display.clear()
def graph(self, event):
if event.action == ACTION_PRESSED:
for _ in range(30):
leds = self.make_graph()
self.display.set_pixels(leds)
sleep(1)
self.display.clear()
if __name__ == "__main__":
display = Display(SenseHat(), RedisConnection())
pause()
from aie_volume_log import AieVolumeLog
from user import User
class AppLogThread(threading.Thread):
def __init__(self, threadID, name, log_num, table, buffer):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.log_num = log_num
self.table = table
self.buffer = buffer
def run(self):
print "Starting " + self.name + '\n'
run_app_log(self.name, self.log_num, self.table, self.buffer)
print "Ending " + self.name
redis_instance = RedisConnection(ReadConfiguration.redis_port, ReadConfiguration.redis_host, ReadConfiguration.redis_db)
def run_app_log(threadName, log_num, table, buffer):
for i in range(log_num):
#print 'memory used: ', psutil.Process(os.getpid()).memory_info().rss
user = User(table)
app_log = AppLog(redis_instance.redis_connection, table, user)
app_volume_log = AieVolumeLog(app_log)
app_log.log_process(buffer)
app_volume_log.log_process()
del user
del app_log
del app_volume_log
def __init__(self):
self.redis = RedisConnection(port=REDIS_PORT)
self.redis_conn=self.redis.redis_connection
self.root_key_name = 'route'
self.ploter = Plot()
#!/usr/bin/env python3.6
"""Serve Humidity information via Flask"""
from flask import Flask, render_template, session
from os import urandom
from redis_connection import RedisConnection
app = Flask(__name__)
rconn = RedisConnection()
@app.route("/")
def home_page():
# humidities = rconn.retrieve(10)
# humidity = round(sum(humidities)/len(humidities), 2)
# return f"<h1>Humidity {humidity}%</h1>"
return render_template("index.html")
@app.route("/data")
def humidity_data():
if "count" in session:
c = session["count"]
else:
c = 100
session["count"] = c
humidity = rconn.retrieve(100)
return str([[x, h] for x, h in zip(range(c - 100, c), humidity)])
'mill': False,
'vinyl_cutter': False,
'soldering_iron': False,
'drill_press': False,
'sewing_machine': False,
'oscilloscope': False,
'user': False,
'superuser': False,
'banned': False
},
'rfid_regex': r'^[0-9A-z]+\n[0-9A-z]{10}$'
}
rfid_reader = RfidReader(SETTINGS['rfid_regex'])
db = RedisConnection(
uid_regex=SETTINGS['rfid_regex'],
user_privileges=SETTINGS['user_privileges'],
)
display = DisplayManager(db=db, user_privileges=SETTINGS['user_privileges'])
dct = {
'4808739405663507168\n2cef529fab': {
"uni": 'ye2184',
"first_name": 'Yonah',
"last_name": 'Elorza',
"user": 1,
"drill": 1,
"mill": 1,
"sewing": 1,
"printer": 1,
"solder": 1,
"oscope": 1,
class NyetBot(BotHandler):
"""Parse all messages, post memes, save memes, random f**k you"""
def __init__(self, token):
super(NyetBot, self).__init__(token)
self.commands = {
'/add_meme': self.add_meme_init,
'/del_meme': self.del_meme_init,
'/show_memes': self.show_memes,
'/discard': self.discard
}
self.average_message_per_fuck = 300
self.f***s = [
'pishov nahui', 'ssaniy loh', 'eto nepravda', 'dvachuiu',
'nyet ty', 'eto pravda', 'on sharit', 'rolidoviy',
'kaka stelit vniz po noge, ege-ge', 'ok, boomer'
]
self.repost_fucks = [
"eto je boyan, petushara", "REEEEEE \n POOOOOST",
"ya eto uje videl, nesi novoe", "davay chto posvejee, valet",
"boyan-huiyan"
]
self.redis_connection = RedisConnection(connection_string)
self.memes = self.redis_connection.get_all_memes()
self.images = self.redis_connection.get_images_tree()
self.users_waiting_del = set([])
self.user_memes = {}
self.user_meme_struct = {'meme_name': None, "meme_pic": None}
self.meme_meta_struct = {'type': None, "adress": None}
self.response_types = set(['text', 'photo'])
def add_meme(self, meme_name, meme_info):
"""Adds meme with picture addres to file"""
self.memes[meme_name] = meme_info
self.redis_connection.set_all_memes(self.memes)
def del_meme(self, meme_name):
"""Delete meme from frile"""
self.memes.pop(meme_name, None)
self.redis_connection.set_all_memes(self.memes)
def show_memes(self, message):
"""Shows availbale commands"""
chat_id = message.get_chat_id()
memes_list = 'Available memes:'
for meme in self.memes.keys():
memes_list += '\n' + meme
self.send_message(chat_id, memes_list)
def random_fuck_you(self, chat_id, message_id):
"""Randomly f**k-offs the user"""
roll = random.randint(1, self.average_message_per_fuck)
if roll == 1:
self.reply_with_random(chat_id, message_id, self.f***s)
def add_meme_init(self, message):
"""Next text message from user will be name of the meme, and image is meme"""
user_id = message.get_sender_id()
chat_id = message.get_chat_id()
message_id = message.get_message_id()
user_meme_struct = self.user_meme_struct.copy()
self.user_memes[user_id] = user_meme_struct
self.send_message(chat_id, 'Send the name of the meme', message_id)
def add_meme_name(self, user_id, chat_id, message_id, name):
"""Next text message from user will be name of the meme, and image is meme"""
self.user_memes[user_id]['meme_name'] = name
self.send_message(chat_id, 'Name set to ' + name + '\nSend any media',
message_id)
def add_meme_pic(self, msg_type, user_id, chat_id, message_id, pic_adress):
"""Next text message from user will be name of the meme, and image is meme"""
self.user_memes[user_id]['meme_pic'] = pic_adress
meme_meta = self.meme_meta_struct.copy()
meme_meta['type'] = msg_type
meme_meta['adress'] = pic_adress
self.add_meme(self.user_memes[user_id]['meme_name'], meme_meta)
self.user_memes.pop(user_id, None)
self.send_message(chat_id, 'Succesfully set up new meme', message_id)
def get_response(self, message):
"""Send accroding action"""
# get all meta information about message
user_id = message.get_sender_id()
chat_id = message.get_chat_id()
message_id = message.get_message_id()
text = message.get_text()
msg_type = message.get_type()
#process itself
self.random_fuck_you(chat_id, message_id)
if user_id in self.user_memes:
if not self.user_memes[user_id]['meme_name']:
if msg_type == 'text':
name = text.rstrip().lstrip().lower()
self.add_meme_name(user_id, chat_id, message_id, name)
elif not self.user_memes[user_id]['meme_pic']:
photo_id = message.get_file_id()
if photo_id:
self.add_meme_pic(msg_type, user_id, chat_id, message_id,
photo_id)
elif user_id in self.users_waiting_del and msg_type == 'text':
name = text.rstrip().lstrip().lower()
self.del_meme_final(user_id, chat_id, message_id, name)
elif msg_type == 'text':
self.parse_for_meme(chat_id, message_id, text)
self.autofellation(message, chat_id, message_id)
self.prevent_duplicates(message, chat_id, message_id)
def del_meme_final(self, user_id, chat_id, message_id, name):
"""Final operations for meme deletion"""
l_name = name.rstrip().lstrip().lower()
if l_name in self.memes:
self.del_meme(l_name)
self.users_waiting_del.remove(user_id)
self.send_message(chat_id, 'Meme deleted', message_id)
def parse_for_meme(self, chat_id, message_id, text):
"""Checks if text contains commans
If yes - returns first, if no - returns None"""
lower_text = text.lower()
for meme in self.memes:
if meme in lower_text:
meme_meta = self.memes[meme]
func = self.get_function_for_sending(meme_meta['type'])
if func is not None:
func(chat_id, meme_meta['adress'], message_id)
def del_meme_init(self, message):
"""Deletes the meme by name"""
user_id = message.get_sender_id()
chat_id = message.get_chat_id()
message_id = message.get_message_id()
self.users_waiting_del.add(user_id)
self.show_memes(message)
self.send_message(chat_id, 'Send the name of the meme to delete',
message_id)
def discard(self, message):
"""Discards user from any waiting ques fror commands"""
user_id = message.get_sender_id()
chat_id = message.get_chat_id()
flag = False
if user_id in self.users_waiting_del:
self.users_waiting_del.discard(user_id)
flag = True
if user_id in self.user_memes:
self.user_memes.pop(user_id, False)
flag = True
if flag:
self.send_message(chat_id, 'Command discarded')
def autofellation(self, message, chat_id, message_id):
"""If user replies to himself - send a meme"""
if message.get_user_id() == message.get_reply_user():
meme_meta = self.memes.get(u'автофелляция')
if meme_meta:
func = self.get_function_for_sending(meme_meta['type'])
if func is not None:
func(chat_id, meme_meta['adress'], message_id)
def is_image_duplicate(self, message):
""" Detects if the image was already posted in the chat"""
res = []
search_dist = 1
urls = filter(lambda x: 'png' in x or 'jpg' in x, message.get_urls())
for link in urls:
try:
response = requests.get(link)
bytes = BytesIO(response.content)
image = Image.open(bytes)
img_hash = dhash.dhash_int(image)
# dont really care what link from the message is repost
res = self.images.find(img_hash, search_dist)
self.images.add(img_hash)
self.redis_connection.set_images_tree(self.images)
except Exception as e:
print(e)
return len(res) > 0
def prevent_duplicates(self, message, chat_id, message_id):
if self.is_image_duplicate(message):
self.reply_with_random(chat_id, message_id, self.repost_fucks)
def reply_with_random(self, chat_id, message_id, replies):
"""
Sends a reply message to message_id in chat_id
with a random content taken from replies
"""
text = random.choice(replies)
self.send_message(chat_id, text, message_id)
from sense_hat import SenseHat
from time import sleep
from redis_connection import RedisConnection
class Humidity_Generator:
"Read humidity data and push to redis as a daemon."""
interval = 1
stdin_path = "/dev/null"
stdout_path = "/dev/null"
stderr_path = "/tmp/humidity_gen_err.txt"
pidfile_path = "/tmp/humidity_gen.pid"
pidfile_timeout = 5
def __init__(self, sensor, conn):
self.sense = sensor
self.conn = conn
def run(self):
while True:
self.conn.add(self.sense.humidity)
sleep(self.interval)
if __name__ == "__main__":
app = Humidity_Generator(SenseHat(), RedisConnection())
with DaemonContext():
app.run()