def __init__(self, lcg, map_size): self.current_player_index = None self.game_started = False self._players = [] self.lcg = lcg self.handlers = Handlers(self) self.mapper = Mapper(self, *map_size)
def __init__(self, agent=None, timeout=10, keep_alive=1, default_headers={}, max_redirect=7): self.timeout = 60 self.max_redirect = max_redirect self._handlers = Handlers() if agent is None: self.agent = 'python-fluffyhttp' else: self.agent = agent if len(default_headers) == 0: default_headers = { 'Connection': 'keep-alive', } if 'User-Agent' not in default_headers: default_headers['User-Agent'] = self.agent self._default_headers = Headers(default_headers) self._poolmanager = PoolManager(maxsize=keep_alive)
def __init__(self, token): logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') self.updater = Updater(token) self.job_queue = self.updater.job_queue self.handlers = Handlers(self.updater, command_handlers=COMMAND_HANDLERS) self.jobs = Jobs(self.job_queue, repeated_jobs=REPEATING_JOBS)
class Cleanr: def __init__(self, token): logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') self.updater = Updater(token) self.job_queue = self.updater.job_queue self.handlers = Handlers(self.updater, command_handlers=COMMAND_HANDLERS) self.jobs = Jobs(self.job_queue, repeated_jobs=REPEATING_JOBS) def start_bot(self): self.handlers.start_handlers() self.jobs.start_jobs() self.updater.start_polling() self.updater.idle()
def main(): parser = argparse.ArgumentParser(prog='deecubes-tg') parser.add_argument('-v', '--version', action='version', version='%(prog)s version ' + VERSION) parser.add_argument('-l', '--log', metavar='LOGLEVEL', type=int, action='store', help='Set log level. 0=> Warning, 1=>Info, 2=>Debug', default=0) args = parser.parse_args() if args.log >= 2: log_level = logging.DEBUG elif args.log == 1: log_level = logging.INFO else: log_level = logging.WARNING logging.basicConfig(level=log_level, format='%(asctime)s: %(filename)s - %(message)s') Handlers()
def __init__(self, agent=None, timeout=10, keep_alive=1, default_headers={}, max_redirect=7): self.timeout = 60 self.max_redirect = max_redirect self._handlers = Handlers() if agent is None: self.agent = "python-fluffyhttp" else: self.agent = agent if len(default_headers) == 0: default_headers = {"Connection": "keep-alive"} if "User-Agent" not in default_headers: default_headers["User-Agent"] = self.agent self._default_headers = Headers(default_headers) self._poolmanager = PoolManager(maxsize=keep_alive)
class Client(object): def __init__(self, agent=None, timeout=10, keep_alive=1, default_headers={}, max_redirect=7): self.timeout = 60 self.max_redirect = max_redirect self._handlers = Handlers() if agent is None: self.agent = 'python-fluffyhttp' else: self.agent = agent if len(default_headers) == 0: default_headers = { 'Connection': 'keep-alive', } if 'User-Agent' not in default_headers: default_headers['User-Agent'] = self.agent self._default_headers = Headers(default_headers) self._poolmanager = PoolManager(maxsize=keep_alive) def add_handler(self, position, cb): self._handlers.add_handler(position, cb) def remove_handler(self, position): self._handler.remove_handler(position) def default_header(self, key): return self.default_headers.get('key') @property def default_headers(self): return self._default_headers def request(self, request): return self._request(request) def head(self, url, headers={}): request = Request('HEAD', url, headers=headers) return self._request(request) def get(self, url, headers={}): request = Request('GET', url, headers=headers) return self._request(request) def put(self, url, headers={}, content=None): request = Request('PUT', url, headers=headers, content=content) return self._request(request) def post(self, url, headers={}, content=None): request = Request('POST', url, headers=headers, content=content) return self._request(request) def delete(self, url, headers={}, content=None): request = Request('DELETE', url, headers=headers) return self._request(request) def mirror(self, url, file): req = Request('GET', url) res = self.request(req) if res.is_success: f = open(file, 'w') f.write(res.content) f.close() last_modified = res.last_modified if last_modified: os.utime(file, (last_modified, last_modified)) def _request(self, request): try: resp = self._make_request(request) except Exception, e: raise e if resp.is_redirect and len(resp.redirects) < self.max_redirect: try: return self._follow_redirect(resp, request) except Exception, e: raise e
from handlers import Handlers from server import WebServer handler = Handlers() server = WebServer(handler.routes) server.run()
from loguru import logger import asyncio from aiogram import Bot, Dispatcher, executor, types from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.contrib.middlewares.logging import LoggingMiddleware from aiogram.dispatcher.webhook import get_new_configured_app, configure_app from handlers import Handlers import settings from aiohttp import web from MyBot import MyBot import config from MyBot import create_bot if __name__ == "__main__": loop = asyncio.get_event_loop() logger.info("!!!!!!!!!!!!!!!") bot = create_bot(config.rmq_channel, config.rmq_connection_string, token=config.bot_token) logger.info("!!!!!!!!!!!!!!!") storage = MemoryStorage() dp = Dispatcher(bot, storage=storage) dp.middleware.setup(LoggingMiddleware()) handler = Handlers(dp, bot) handler.register() #app = web.Application() #loop.run_until_complete(bot.set_webhook(settings.BOT_WEBHOOK_URL)) #configure_app(dispatcher = dp, app = app, path = settings.BOT_WEBHOOK_PATH) #web.run_app(app, host= "0.0.0.0", port=443) executor.start_polling(dp, loop=loop, skip_updates=True)
class Client(object): def __init__(self, agent=None, timeout=10, keep_alive=1, default_headers={}, max_redirect=7): self.timeout = 60 self.max_redirect = max_redirect self._handlers = Handlers() if agent is None: self.agent = "python-fluffyhttp" else: self.agent = agent if len(default_headers) == 0: default_headers = {"Connection": "keep-alive"} if "User-Agent" not in default_headers: default_headers["User-Agent"] = self.agent self._default_headers = Headers(default_headers) self._poolmanager = PoolManager(maxsize=keep_alive) def add_handler(self, position, cb): self._handlers.add_handler(position, cb) def remove_handler(self, position): self._handler.remove_handler(position) def default_header(self, key): return self.default_headers.get("key") @property def default_headers(self): return self._default_headers def request(self, request): return self._request(request) def head(self, url, headers={}): request = Request("HEAD", url, headers=headers) return self._request(request) def get(self, url, headers={}): request = Request("GET", url, headers=headers) return self._request(request) def put(self, url, headers={}, content=None): request = Request("PUT", url, headers=headers, content=content) return self._request(request) def post(self, url, headers={}, content=None): request = Request("POST", url, headers=headers, content=content) return self._request(request) def delete(self, url, headers={}, content=None): request = Request("DELETE", url, headers=headers) return self._request(request) def mirror(self, url, file): req = Request("GET", url) res = self.request(req) if res.is_success: f = open(file, "w") f.write(res.content) f.close() last_modified = res.last_modified if last_modified: os.utime(file, (last_modified, last_modified)) def _request(self, request): try: resp = self._make_request(request) except Exception, e: raise e if resp.is_redirect and len(resp.redirects) < self.max_redirect: try: return self._follow_redirect(resp, request) except Exception, e: raise e
def customErr(self, callobj, args, kwargs, e, source, frame): """ NAME errorhandler FILE errorhandler.py DESCRIPTION Used for generating both custom unhandled exceptions, and for handling exceptions with specific actions. Creates the opportunity for cutom code to be attached to errors and resolve them in a clean format An existing 'self' object must be passed in with an existing self.log object associated with it!! Uses the self.log() parameter of an EXISTING instantiated log object to generate output. A logger has to be instantiated in the calling class for this method to be used. EXAMPLE (USAGE) from inspect import getmembers from inspect import stack import errorhandler customerr = errorhandler.ErrorHandler(self.log) self.err = customerr.err() try: print this wont work except: e = "".join(["ErrorIdentifier: ", "Additional information."]) self.lasterr = self.err(e, getmembers(self), stack()) METHODS ErrorHandler(self, e, source, frame) Error message handler. Generates logfile output self = The class object using the error handler. Must contain a self.log object. e = The error message passed from the calling object. I.e. except Exception, e: source = The inspect.getmembers(self) passed in from the error call. frame = The inspect.stack() passed in from the error call. TEMPLATE(self, e) Create custom error message and handling code HIDDEN METHODS _format_original_error(e) _log_error(self, message, e) """ ############################################################################### # FOR NOW, LEAVE 'e' ALONE # # Source is inspect.getmembers(self) # # EXAMPLE SOURCE (a list of tuples): # #[('MAX_LENGTH', 16384), # # ('TSTART', 'TWILIOSOCK'), # # ('__doc__', None), # # ('__implemented__', <implementedBy twisted.internet.protocol.Protocol>), # # ('__init__', <bound method Handler.__init__ of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('__module__', 'twistedlisten'), # # ('__providedBy__', <implementedBy twistedlisten.Handler>), # # ('__provides__', <implementedBy twistedlisten.Handler>), # # ('_buffer', ''), # # ('_busyReceiving', False), # # ('_checkdata', <bound method Handler._checkdata of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('_parsedata', <bound method Handler._parsedata of <twistedlisten.Handler instance at 0x02E05EB8>>), # # ('<some_method>', <bound method <class>.<method> of <someinstance instance at 0x02E05EB8>>), # #] # errorin = str(source[6][1]) # errorin = errorin.replace("implementedBy", "") # errorin = "".join(c for c in errorin if c not in "<>") # errorin = errorin + "." + str(frame[0][3]) # errorin = errorin + "(line:" + str(frame[0][2]) + "): " # e = errorin + str(e) # import handlers #333 # This calls the proper handler method from 'handlers' # NOTE: The error keyword MUST MATCH THE METHOD NAME # NOTE: A string search is used to match the method name to contents # of the error string passed in. # THIS MEANS if you have two methods, 'ERR1' AND 'ERR10', 'ERR1' # will always be the one found...SO IT IS RECOMMENDED YOU NAME # THE METHODS VERY UNIQUELY AND CAREFULLY. # I.e. 'StringNotFoundInLogError' for key in Handlers.__dict__.keys(): if (str(key).lower() in str(e).lower()): return Handlers.__dict__[key](callobj, args, kwargs, e) return Handlers.UnknownException(callobj, args, kwargs, e)
class Overseer(object): def __init__(self, lcg, map_size): self.current_player_index = None self.game_started = False self._players = [] self.lcg = lcg self.handlers = Handlers(self) self.mapper = Mapper(self, *map_size) def handle(self, environ, start_response): logger.info('Using overseer %s' % id(self)) socket = environ["wsgi.websocket"] logger.debug(socket.__dict__) player = Player(socket, start_response) enter_teh_infiniteh_loopah = True if self.game_started: logger.info( '%s tried to connect, but game has already started' % player.id ) logger.info('Delegating %s to new overseer...' % player.id) self.lcg.new_overseer() return self.lcg.redirect_to_overseer(environ, start_response) logger.info('%s connected' % player.id) while enter_teh_infiniteh_loopah: try: line = socket.receive() except socketerror: break if not line: break line = line.strip() if not line: break logger.debug('%s -> %s' % (player.id, line)) try: parsed = json.loads(line) except ValueError: player.exception('What the hell are you sending to me?') continue try: self.delegate(player, parsed) except (GameError, ServerError) as e: player.exception(e) logger.info('%s raised %s' % (player.id, e)) continue self.remove_player(player) try: socket.close() except socketerror: # whatever, I no more care about this socket pass logger.info('%s disconnected' % player.id) def delegate(self, who, msg): if not ('type' in msg and 'message' in msg): raise ServerError('Not enough JSON fields') what = msg['type'] message = msg['message'] self.handlers.do(who, what, message) @property def players(self): return [p for p in self._players if p and p.name] @property def current_player(self): return self._players[self.current_player_index] @current_player.setter def current_player(self, player): self.current_player_index = self._players.index(player) def next_player(self): if self.current_player_index is None: self.current_player_index = 0 else: while self.current_player: i = (self.current_player_index+1) % len(self._players) self.current_player_index = i valid = ( self.current_player and self.current_player in self.mapper.remaining_players ) if valid: break townhall_count = self.mapper.get_townhalls_count(self.current_player) self.current_player.action_points = 10 + (townhall_count-1)*2 for p in [p for p in self.players if p is not self.current_player]: p.send('nextPlayer', {'nickname': self.current_player.name}) self.current_player.send('yourTurn', self.current_player.state) def remove_player(self, player): try: if not self.game_started: self._players.remove(player) else: i = self._players.index(player) self._players[i] = None except ValueError: # lol pass # Notify others for p in self.players: p.send('playerLeft', {'nickname': player.name}) def end_game(self, winner): for p in self.players: p.send('gameEnd', {'winner': winner.name}) self._players = [p for p in self.players] self.game_started = False self.current_player_index = None
from dynaconf import settings from telegram.ext import Updater from handlers import Handlers from models import connect_to_db updater = Updater(settings.BOT_TOKEN, use_context=True) job_queue = updater.job_queue connect_to_db() Handlers.register(updater.dispatcher) job_queue.run_repeating(Handlers.send_reminds, interval=60, first=0) updater.start_polling() updater.idle()