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()