def compile_and_send_pdf(pdf_filename, contents, runs=1, dirpath=None):
if not dirpath:
dirpath = tempfile.mkdtemp()
texfile = os.path.join(dirpath, "file.tex")
pdffile = os.path.join(dirpath, "file.pdf")
logfile = os.path.join(dirpath, "file.texlog")
logger().info("Temp directory for %s is %s" % (pdf_filename, dirpath))
with open(texfile, "w", encoding="utf-8") as f:
f.write(contents)
old_cwd = os.getcwd()
os.chdir(dirpath)
for i in range(runs):
os.system("pdflatex -interaction=nonstopmode file.tex > file.texlog")
os.chdir(old_cwd)
if os.path.exists(pdffile) and not latex_has_errors(logfile):
return send_file(pdffile, mimetype='application/pdf')
else:
texlog = open(os.path.join(dirpath, "file.texlog"), encoding="iso-8859-1").read()
errstr = "An error occurred when compiling the LaTeX file for %s.\n\nLaTeX output was:\n%s" % (pdf_filename, texlog)
return errstr.replace("\n", "<br/>\n")
def scrap_new_senadores(ids):
nuevos = list()
for _id in ids:
logger('\tsid={}'.format(_id))
nuevos.append(senadores.fetch_detail(_id))
sleep(0.7)
return nuevos
def scrap_new_comisiones(_comisiones):
nuevas = []
for comision in _comisiones:
logger('\tcid={}'.format(comision['id']))
comisiones.fetch_detail(comision)
nuevas.append(comision)
sleep(0.7)
return nuevas
def scrap_new_proyectos(_proyectos):
nuevos = []
for proyecto in _proyectos:
logger('\tboletin={}'.format(proyecto['boletin']))
proyectos.fetch_resumen(proyecto)
nuevos.append(proyecto)
sleep(0.7)
return nuevos
def trigger_mailers(self):
if len(self.updated_senators) == 0:
return
logger('Gatillando envíos de updates a suscriptores')
for sid in self.updated_senators:
logger('\tsid={}'.format(sid))
trigger_mailer_senator(sid)
def set_up(self):
logger('Creating table "messages"')
cursor = self.connection.cursor()
cursor.execute("""CREATE TABLE messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
posted_on DATETIME DEFAULT (datetime('now','localtime')),
user TEXT DEFAULT 'Anónimo',
content TEXT NOT NULL)""")
self.connection.commit()
logger('Table "messages" created')
def actualizar_senadores(self):
logger('Verificando cambios en los senadores')
web_ids = set(self.scrap_ids_senadores())
db_ids = set(db.select(self.connection, ['id'], 'Senadors'))
diff = web_ids - db_ids
if len(diff) == 0:
logger('No hay cambios')
return
self.updated_senators.update(diff)
logger('Cambios detectados, scrapeando nueva información')
nuevos = self.scrap_new_senadores(diff)
logger('Agregando {} senador{} a la base de datos'.format(
len(nuevos), 'es' if len(nuevos) > 1 else ''))
db.insert(self.connection, 'Senadors', nuevos)
logger('Senadores agregados a la base de datos')
self.agregar_periodos(map(lambda senador: senador['id'], nuevos))
def actualizar_comisiones(self):
logger('Verificando cambios en comisiones vigentes')
web_data = comisiones.fetch_new_comisiones()
db_ids = set(db.select(self.connection, ['id'], 'Comitions'))
web_ids = set(map(lambda com: com['id'], web_data))
diff = web_ids - db_ids
if len(diff) == 0:
logger('No hay cambios')
return
new_data = list(filter(lambda com: com['id'] in diff, web_data))
logger('Cambios detectados, scrapeando nueva información')
nuevas = self.scrap_new_comisiones(new_data)
logger('Agregando {} comisi{} a la base de datos'.format(
len(nuevas), 'iones' if len(nuevas) > 1 else 'ón'))
db.insert(self.connection, 'Comitions', nuevas)
logger('Comisiones agregadas a la base de datos')
self.agregar_integrantes(map(lambda com: com['id'], nuevas))
def actualizar_proyectos(self):
logger('Verificando cambios en proyectos de ley')
web_data = proyectos.fetch_new_proyectos(self.custom_form_date)
db_ids = set(db.select(self.connection, ['boletin'], 'Proyectos'))
web_ids = set(map(lambda proy: proy['boletin'], web_data))
diff = web_ids - db_ids
if len(diff) == 0:
logger('No hay cambios')
return
self.new_leyes = diff
new_data = list(filter(lambda proy: proy['boletin'] in diff, web_data))
logger('Cambios detectados, scrapeando nueva información')
nuevos = self.scrap_new_proyectos(new_data)
logger('Agregando {} proyecto{} a la base de datos'.format(
len(nuevos), 's' if len(nuevos) > 1 else ''))
db.insert(self.connection, 'Proyectos', nuevos)
logger('Proyectos agregados a la base de datos')
self.agregar_senadores_autores(map(lambda proy: proy['id'], nuevos))
def tear_down(self):
logger('Dropping table "messages"')
try:
cursor = self.connection.cursor()
cursor.execute("DROP TABLE messages")
self.connection.commit()
logger('Table "messages" deleted')
except OperationalError:
logger('No table "messages" found')
def agregar_integrantes(self, cids):
logger('Scrapeando integrantes de nuevas comisiones')
integrantes = []
for cid in cids:
logger('\tpid={}'.format(cid))
integrantes += comisiones.fetch_integrantes(cid)
sleep(0.7)
logger('Agregando {} integrante{} a la base de datos'.format(
len(integrantes), 's' if len(integrantes) > 1 else ''))
db.insert(self.connection, 'SenatorComitions', integrantes)
def agregar_senadores_autores(self, pids):
logger('Scrapeando autores de nuevos proyectos')
autores = []
for pid in pids:
logger('\tpid={}'.format(pid))
autores += proyectos.fetch_autores(pid)
sleep(0.7)
logger('Agregando {} autor{} a la base de datos'.format(
len(autores), 'es' if len(autores) > 1 else ''))
db.insert(self.connection, 'SenadorProyectos', autores)
new_sids = set(map(lambda rel: rel['sid'], autores))
self.updated_senators.update(new_sids)
def actualizar_asistencias(self):
logger('Verificando cambios en asistencias')
refreshed_data = asistencias.fetch_new_asistencias()
db_ids = db.select(self.connection, ['lid'], 'Assistance')
if refreshed_data[0]['lid'] in db_ids:
logger('Legislación ya existe, borrando los datos anteriores')
condition = map(
lambda d: '(lid={} AND sid={})'.format(d['lid'], d['sid']),
refreshed_data)
db.delete(self.connection, 'Assistance', ' OR '.join(condition))
db.insert(self.connection, 'Assistance', refreshed_data)
logger('Asistencias agregadas a la base de datos')
def check_correct_orientation(info, verbose=False):
"""
Verifies the card is right-side-up.
@returns True if right-side-up
@returns False if wrong-side-up
"""
logger(info, verbose)
check_pattern = re.compile(constants.CHECK_ORIENTATION_PATTERN)
print(re.findall(constants.CHECK_ORIENTATION_PATTERN, info))
if len(re.findall(constants.CHECK_ORIENTATION_PATTERN, info)) == 0:
logger('Wrong way up', verbose)
return False
logger('Right way up!', verbose)
return True
getRelativeFp,
logger,
readSql,
)
import os
import pandas as pd
from fnmatch import fnmatch
import numpy as np
# %% CONSTANTS
OTHERPREFIXMAP = {"tm": "opp", "opp": "tm"}
# %% Logging
log = logger(
fp=getRelativeFp(__file__, f"logs/loadDatabase.log"),
fileLevel=10,
consoleLevel=20,
removeOldFile=True,
)
# %% Load calendar
@log.timeFuncInfo
def load_calendar():
"Relies on games to be loaded into database"
q = """
select
season
,min(date) as min
,max(date) as max
from games
group by season
import numpy as np
from helpers import (
dfToTable,
executeSql,
get_unique_permutations,
getRelativeFp,
readSql,
logger,
)
import pandas as pd
# %% Logging
log = logger(
fp=getRelativeFp(__file__, f"logs/teamdates.log"),
fileLevel=10,
consoleLevel=20,
)
# %% constants
OTHERPREFIXMAP = {"tm": "opp", "opp": "tm"}
SUMMABLE_LIST = [
"game",
"poss",
"mins",
"win",
"loss",
"pts",
"ast",
"availor",
"blk",
def chat_client():
if (len(sys.argv) < 3):
print('Usage : python n1.py hostname port')
sys.exit()
host = sys.argv[1]
port = int(sys.argv[2])
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 10101))
s.settimeout(2)
# connect to remote host
try:
s.connect((host, port))
except:
print('Unable to connect')
sys.exit()
print 'Connected to router. You are N1.\n<dest> <protocol> <message>'
sys.stdout.write('[Me] ')
sys.stdout.flush()
while 1:
socket_list = [sys.stdin, s]
# Get the list sockets which are readable
ready_to_read, ready_to_write, in_error = select.select(
socket_list, [], [])
for sock in ready_to_read:
if sock == s:
# incoming message from remote server, s
data = sock.recv(4096)
if not data:
print('\nDisconnected from router')
sys.exit()
else:
#print data
sys.stdout.write(data)
sys.stdout.write('[Me] ')
sys.stdout.flush()
else:
# user entered a message
msg = sys.stdin.readline()
dest = msg.split(' ')[0]
protocol = msg.split(' ')[1]
message = msg.split(' ')[2]
s.send(
helpers.frame('N1', '0x1A', 'R1', dest, protocol, message))
if protocol == "0":
print '[reply] ' + helpers.frame(
'R1', helpers.node_to_IP('N3'), 'N1', "N1", protocol,
message)
if dest == "N3":
helpers.logger(
'sniff_logs.txt',
helpers.frame('R2', '0x1A', 'N3', dest, protocol,
message))
sys.stdout.write('[Me] ')
sys.stdout.flush()
def seed(self):
self.tear_down()
self.set_up()
self.close_connection()
logger('Done!')
def generate_badges(pdf_filename, template_filename, table):
dirpath = tempfile.mkdtemp()
logger().info("Temp directory for badges is %s" % (dirpath))
# ensure paths exist
iqdir = os.path.join(dirpath, "iq")
if not os.path.exists(iqdir):
os.makedirs(iqdir)
flagdir = os.path.join(dirpath, "flags")
if not os.path.exists(flagdir):
os.makedirs(flagdir)
shutil.copyfile("static/Logo.pdf", os.path.join(dirpath, "Logo.pdf"))
songs = read_songs()
i = 0
prev_part = -1
just_ended = MutableBoolean() # type: MutableBoolean
just_ended.val = False
f = None
for p in session.query(table).order_by(table.final_part):
# download flag if necessary
flag_filename = os.path.join(flagdir, "%s.png" % p.country)
if not os.path.exists(flag_filename):
to_download = p.country.lower()
if to_download == "hk":
to_download = "cn"
download_binary_file("http://flagpedia.net/data/flags/normal/%s.png" % to_download, flag_filename)
fp = p.final_part
if fp != prev_part:
if f:
f.flush()
close(f, i, just_ended)
local_tex_name = "%s.tex" % parts[fp]
f = open(os.path.join(dirpath, local_tex_name), "w", encoding="utf-8")
prev_part = fp
i = 0
if i % 2 == 0:
f.write(start.replace("PPPPP", parts[prev_part]) + "\n")
just_ended.val = False
f.write(makebadge(i, p, iqdir) + "\n")
just_ended.val = False
i = i + 1
if i % 2 == 0:
print_end(f, just_ended)
f.flush()
close(f, i, just_ended)
template = texenv.get_template(template_filename)
tex = template.render(event_name=conf.get("application", "name"), songs=songs)
return compile_and_send_pdf(pdf_filename, tex, runs=2, dirpath=dirpath)
import logging
import time
import helpers
from __init__ import app
from helpers import log_file_name, logger
import main
# set up logging
root_logger = logging.getLogger()
root_logger.setLevel(logging.INFO)
handler = logging.FileHandler(log_file_name, 'a', 'utf-8')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handler.setFormatter(formatter)
root_logger.addHandler(handler)
helpers._logger = logging.getLogger(__name__)
start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
logger().info("Gunicorn started at %s" % str(start_time))
if __name__ == "__main__":
app.run()
success = True
else:
if not success:
return await bot.send_message(
message.channel,
'specify domain(s) to remove: `!remove example.com`')
# print the whitelist, or, if add/remote worked, print the whitelist
if cmd == 'list' or success:
return await bot.send_message(
message.channel,
'whitelist contains: ```{}```'.format(repr(whitelist)))
@bot.event
async def on_ready():
# TODO: code to set/save the current nickname
debug('login: {}#{}'.format(bot.user.name, bot.user.discriminator))
for server in bot.servers:
if server.get_member(bot.user.id).display_name != SHRUGGIE_NICKNAME:
await bot.change_nickname(
server.get_member(bot.user.id),
SHRUGGIE_NICKNAME,
)
try:
bot.run(SHRUGGIE_APP_TOKEN)
except:
logger(None).exception('exception:')
import logging
import time
import helpers
from __init__ import app
from helpers import log_file_name, logger
import main
# set up logging
root_logger = logging.getLogger()
root_logger.setLevel(logging.INFO)
handler = logging.FileHandler(log_file_name, 'a', 'utf-8')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handler.setFormatter(formatter)
root_logger.addHandler(handler)
helpers._logger = logging.getLogger(__name__)
start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
logger().info("Gunicorn started at %s" % str(start_time))
if __name__ == "__main__":
app.run()
def actualizar_proyectos_por_comision(self):
logger(
'Hay {0} nuevo{1} proyecto{1}, se requiere verificar de que comisiones son'
.format(len(self.new_leyes),
's' if len(self.new_leyes) > 1 else ''))
cids = db.select(self.connection, ['id'], 'Comitions')
correspondencias = []
for cid in cids:
if len(self.new_leyes) == 0:
logger('No hay mas proyectos por buscar')
break
logger('\tcid={}'.format(cid))
proyectos_en_comision = comisiones.fetch_proyectos_in_comision(cid)
inter = self.new_leyes.intersection(proyectos_en_comision)
if len(inter) > 0:
logger('\t\t{0} proyecto{1} encontrado{1}'.format(
len(inter), 's' if len(inter) > 1 else ''))
for boletin in inter:
correspondencias.append({'cid': cid, 'boletin': boletin})
self.new_leyes.remove(boletin)
sleep(0.7)
if len(self.new_leyes) > 0:
logger('Quedaron {} proyectos sin comisión válida. '.format(
len(self.new_leyes)) +
'Se asume que son de la cámara de diputados')
correspondencias += list(
map(lambda bol: {
'cid': 0,
'boletin': bol
}, self.new_leyes))
correspondencias.sort(key=lambda c: c['boletin'])
correspondencias = self.get_pids_from_boletines(correspondencias)
logger('Agregando {} relacion{} a la base de datos'.format(
len(correspondencias), 'es' if len(correspondencias) > 1 else ''))
db.insert(self.connection, 'ProjectComitions', correspondencias)
logger('Proyectos agregados a la base de datos')
def agregar_periodos(self, ids):
logger('Recolectando información de los periodos')
periodos_db = periodos.fetch_periodos(ids)
logger('Agregando periodos a la base de datos')
db.insert(self.connection, 'Periodos', periodos_db)
logger('Periodos agregados a la base de datos')
def commit_actualizacion(self):
logger('Comiteando update a la base de datos')
db.insert(self.connection, 'Updates', [{
'"createdAt"': datetime.now()
}])
