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