def test_no_arguments(self):
try:
generate_pdf('www.')
except IOError:
pass
else:
raise AssertionError('Should have raised a IOError')
def test_no_arguments(self):
try:
generate_pdf('www.')
except IOError:
pass
else:
raise AssertionError('Should have raised a IOError')
def test_no_arguments(self):
try:
generate_pdf()
except TypeError:
pass
else:
raise AssertionError('Should have raised a TypeError')
def test_no_arguments(self):
try:
generate_pdf()
except TypeError:
pass
else:
raise AssertionError('Should have raised a TypeError')
def generateSalesPdf(data):
template = env.get_template(SALES_REPORT_TEMPLATE)
template_vars = data
html_output = template.render(template_vars)
pdf = pydf.generate_pdf(html_output)
with open('static/pdf/salesreport.pdf', 'wb') as f:
f.write(pdf)
def get_csa(self):
Panelist = apps.get_model('api.panelist')
Member = apps.get_model('api.member')
Song = apps.get_model('api.song')
panelists = Panelist.objects.filter(
kind=Panelist.KIND.official,
round__session=self.session,
category__gt=Panelist.CATEGORY.ca,
).distinct().order_by(
'category',
'person__last_name',
)
appearances = self.appearances.order_by('-num', ).prefetch_related(
'songs', )
songs = Song.objects.select_related('chart', ).filter(
appearance__competitor=self, ).prefetch_related(
'scores',
'scores__panelist__person',
).order_by(
'-appearance__round__num',
'num',
)
context = {
'competitor': self,
'panelists': panelists,
'appearances': appearances,
'songs': songs,
}
rendered = render_to_string('csa.html', context)
file = pydf.generate_pdf(rendered)
content = ContentFile(file)
return content
def save(self):
date = 'Дата'
lot_number = self.qle_lot_number.text()
description = 'PSA Calibration Curve SQ201'
organization = self.qle_organization.text()
position = self.qle_position.text()
full_name = self.qle_fullName.text()
phone = self.qle_phone.text()
measurementResult = self.lbl_result.text()
test_type = self.combo_test_type.currentText()
html = '<h1>Отчет</h1>'
html += '<p>Дата: {}</p>'.format(date)
html += '<p>Номер партии теста: {}</p>'.format(lot_number)
html += '<p>Тип теста: {}</p>'.format(test_type)
html += '<p>Описание: {}</p>'.format(description)
html += '<h1>Результаты измерения</h1>'
html += '<p>{}<p/>'.format(measurementResult)
html += '<h1>Организация и оператор</h1>'
html += '<p>Организация: {}</p>'.format(organization)
html += '<p>Оператор: {}, {}</p>'.format(full_name, position)
html += '<p>Телефон: {}</p>'.format(phone)
html += '<h1>Данные калибровки</h1>'
html += '<p>Серия: {}, срок годности: {}</p>'.format('F12181', 'Дата')
html += '<p>Файл: {}, надежность: {}</p>'.format('Файл', '92.6%')
html += '<p>Оператор: {}, {}</p>'.format('ФИО', 'должность')
html += '<p>Телефон: {}</p>'.format('9999999999')
pdf = pydf.generate_pdf(html, encoding='utf-8')
os.chdir('process')
with open('protocol_result.pdf', 'wb') as f:
f.write(pdf)
os.chdir('../')
self.win_mesurement.deleteLater()
def get_variance(self):
Score = apps.get_model('api.score')
Panelist = apps.get_model('api.panelist')
songs = self.songs.order_by('num')
scores = Score.objects.filter(
kind=Score.KIND.official,
song__in=songs,
).order_by(
'category',
'panelist__person__last_name',
'song__num',
)
panelists = self.round.panelists.filter(
kind=Panelist.KIND.official,
category__gt=Panelist.CATEGORY.ca,
).order_by(
'category',
'person__last_name',
)
variances = []
for song in songs:
variances.extend(song.dixons)
variances.extend(song.asterisks)
variances = list(set(variances))
context = {
'appearance': self,
'songs': songs,
'scores': scores,
'panelists': panelists,
'variances': variances,
}
rendered = render_to_string('variance.html', context)
pdf = pydf.generate_pdf(rendered, enable_smart_shrinking=False)
content = ContentFile(pdf)
return content
def get(self, request, *args, **kwargs):
pk = self.kwargs.get("pk")
invoice = Invoice.objects.get(id=pk)
context = {
"order": invoice.order,
"orderlines":
invoice.order.orderline_set.all().order_by("product"),
"invoice": invoice,
"buyer": invoice.buyer,
"send_email": False,
"bank": settings.BANK,
"branch": settings.BRANCH,
"branch_code": settings.BRANCH_CODE,
"swift_code": settings.SWIFT_CODE,
"account_number": settings.ACCOUNT_NUMBER,
"account_name": "TURFD",
"account_type": settings.ACCOUNT_TYPE,
"email_address": settings.EMAIL_HOST_USER,
"phone_number": settings.PHONE_NUMBER,
}
template = get_template("sales/invoice_email.html")
html = template.render(
context) # Renders the template with the context data.
pdf = pydf.generate_pdf(
html,
page_size="A4",
margin_left="15mm",
margin_right="15mm",
margin_top="15mm",
margin_bottom="15mm",
orientation="Landscape",
)
return HttpResponse(pdf, content_type="application/pdf")
def generateDepletedReport(data):
template = env.get_template(DEPLETED_REPORT_TEMPLATE)
template_vars = data
html_output = template.render(template_vars)
pdf = pydf.generate_pdf(html_output)
with open('static/pdf/depletedreport.pdf', 'wb') as f:
f.write(pdf)
def test_custom_size(self):
pdf_content = generate_pdf(
'<html><body>testing</body></html>',
page_height='50mm',
page_width='50mm',
)
assert pdf_content[:4] == byteify('%PDF')
def reporte_pdf(request, id, fecha):
template = get_template('pdf.html')
# obtener el reporte que se quiere ver
r = Reporte.objects.get(id=id)
context = r.__dict__
# obtener clientes y chofer de la entrega
context['clientes'] = r.clientes.all()
context['chofer'] = r.chofer.nombre
# renderear la template con el contexto
html = template.render(context)
# usar pdfkit si se corre localmente,
# pydf si esta en produccion (Heroku)
if settings.DEBUG:
pdf = pdfkit.from_string(html, False)
else:
pdf = pydf.generate_pdf(html)
# nombre y datos del archivo y la respuesta http
filename = 'Reporte {id} - {fecha}'.format(id=id, fecha=r.fecha_str)
response = HttpResponse(pdf, content_type='application/pdf')
response['Content-Disposition'] = 'filename="{name}.pdf"'.format(
name=filename)
return response
def test_pdf_title():
pdf_content = generate_pdf('<html><head><title>the title</title></head><body>hello</body></html>')
assert pdf_content[:4] == b'%PDF'
text = pdf_text(pdf_content)
title = 'the title'.encode('utf-16be')
assert b'\n/Title (\xfe\xff%s)\n' % title in pdf_content
assert 'hello\n\n\x0c' == text
def get_page(self, url):
response = Response()
try:
# Initilized the chrome driver
print("Initilized the chrome driver")
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--window-size=1420,1080')
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
browser = webdriver.Chrome(chrome_options=chrome_options)
# browser kibana
print("browser kibana")
browser.get(url)
delay = 10000
# wait till specific classes appears
print("wait till specific classes appears")
WebDriverWait(browser, delay).until(
EC.presence_of_element_located((By.CLASS_NAME, 'kbn-table')))
body = browser.find_element_by_class_name(
"kbn-table").get_attribute('innerHTML')
# calculate number of pages exists and loop them
print("calculate number of pages exists and loop them")
pages = (str(
browser.find_element_by_class_name(
"kuiToolBarText").text).split(" ")[2]).replace(",", "")
pages = math.ceil(int(pages) / 50) - 1
print("pages found {}".format(pages))
for page in range(1, pages):
browser.execute_script(
"document.getElementsByClassName('kuiButton')[1].click()")
chunk = browser.find_element_by_class_name(
"kbn-table").get_attribute('innerHTML').replace(
"<tbody>", "")
body += chunk
# apply table tags and generate pdf
print("apply table tags and generate pdf")
pdf = pydf.generate_pdf("<table>" + body + "</table>")
with open('out.pdf', 'wb') as f:
f.write(pdf)
return json.loads(
json.dumps((response.get_response(Constants.SUCCESS,
Constants.SUCCESS))))
except Exception as e:
logging.exception(e)
return abort(
make_response(
jsonify(
response.get_response(Constants.SERVER_ERROR,
Constants.SERVER_ERROR)),
response.get_code(Constants.SERVER_ERROR)))
def test_pdf_title():
pdf_content = generate_pdf(
'<html><head><title>the title</title></head><body>hello</body></html>')
assert pdf_content[:4] == b'%PDF'
text = pdf_text(pdf_content)
title = 'the title'.encode('utf-16be')
assert b'\n/Title (\xfe\xff%s)\n' % title in pdf_content
assert 'hello\n\n\x0c' == text
def safe_pdf(html, **kwargs):
"""
Creates a base 64 encoded string representing a pdf which can safely
be jsonified.
"""
# Isn't there a more efficient way of doing this, which doesn't increase the
# string length as much?
pdf = generate_pdf(html, **kwargs)
return base64.b64encode(pdf)
def handle_commands(self, msg):
command = msg.split(' ')[0]
remainder = msg[len(command) + 1:]
if command == '/sheets':
self.send_user_list_of_their_sheets()
elif command == '/open':
# if sheet exists then open it up and write each new message as a new element
try:
if self.session.current_sheet_id != None:
self.sender.sendMessage("Closed sheet.")
self.session.current_sheet_id = self.sheets[remainder]
self.sender.sendMessage(
"Opened sheet '{}' for writing.".format(remainder))
except:
self.session.current_sheet_id = self.ph.new_sheet(
remainder, self.remote_user_id)
self.sheets[remainder] = self.session.current_sheet_id
self.sender.sendMessage(
"Created a sheet called '{}' and opened it for writing.".
format(remainder))
elif command == '/close':
# close current sheet
self.session.current_sheet_id = None
elif command == '/delete':
# delete a sheet
raise NotImplemented
elif command == '/show':
if remainder in self.sheets.keys():
this_sheet_id = self.sheets[remainder]
elif len(remainder) == 0:
this_sheet_id = self.session.current_sheet_id
else:
self.sender.sendMessage("No sheet with that name")
elements = self.ph.get_data_in_sheet(this_sheet_id)
tl = Timeline("", elements)
output_filename = str(int(random.random() * 10**6)) + ".pdf"
pdf = pydf.generate_pdf(tl._getHTML())
with open(output_filename, 'wb') as f:
f.write(pdf)
with open(output_filename, 'rb') as f:
self.sender.sendDocument(f)
else:
# write the message to the currently opened sheet.
if self.session.current_sheet_id != None:
self.ph.new_element(command + " " + remainder,
self.session.current_sheet_id)
else:
self.sender.sendMessage(
"No currently open sheet! Open a sheet for writing with the /open command"
)
def generate_jacket():
rendered = render_template('example_pdf.html', items=request.args)
try:
pdf = pydf.generate_pdf(rendered)
response = make_response(pdf)
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = 'inline; filename=output.pdf'
return response
except:
return rendered
def genera_pdf(rutarchivo, resultados):
"""
genera pdf apoyandose en template chameleon.
usa lista de dicts q le pasa 'lee_csv'
"""
pagina_0 = chameleon.PageTemplateFile(template)
pagina = pagina_0.render(resultados=resultados)
# print(pagina) #------------------------------------------
pdf = pydf.generate_pdf(pagina, orientation='Landscape', page_size='A3')
with open(rutarchivo, 'wb') as f:
f.write(pdf)
def generate_pdf(self, content):
try:
name = str(uuid.uuid4()) + ".pdf"
#pdfkit.from_string(content, name) # To be used if nothing works
pdf = pydf.generate_pdf(content)
with open(name, 'wb') as f:
f.write(pdf)
return os.path.abspath(name)
except Exception as e:
print(e)
def pdf():
try:
from pydf import generate_pdf
html = '<h1>This is HTML</h1>'
pdf_content = generate_pdf(html)
response = make_response(pdf_content)
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = 'inline; filename=test.pdf'
return response
except Exception:
exc = traceback.format_exc()
return Response(exc, content_type='text/plain')
def pdf():
try:
from pydf import generate_pdf
html = '<h1>This is HTML</h1>'
pdf_content = generate_pdf(html)
response = make_response(pdf_content)
response.headers['Content-Type'] = 'application/pdf'
response.headers['Content-Disposition'] = 'inline; filename=test.pdf'
return response
except Exception:
exc = traceback.format_exc()
return Response(exc, content_type='text/plain')
def get_variance(self):
Score = apps.get_model('api.score')
Panelist = apps.get_model('api.panelist')
# Songs Block
songs = self.songs.annotate(
tot_score=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
),
),
).order_by('num')
scores = Score.objects.filter(
panelist__kind=Panelist.KIND.official,
song__appearance=self,
).order_by(
'category',
'panelist__person__last_name',
'song__num',
)
panelists = self.round.panelists.filter(
kind=Panelist.KIND.official,
category__gt=Panelist.CATEGORY.ca,
).order_by(
'category',
'person__last_name',
)
variances = []
for song in songs:
variances.extend(song.dixons)
variances.extend(song.asterisks)
variances = list(set(variances))
tot_points = scores.aggregate(sum=Sum('points'))['sum']
context = {
'appearance': self,
'songs': songs,
'scores': scores,
'panelists': panelists,
'variances': variances,
'tot_points': tot_points,
}
rendered = render_to_string('reports/variance.html', context)
pdf = pydf.generate_pdf(
rendered,
enable_smart_shrinking=False,
orientation='Portrait',
margin_top='5mm',
margin_bottom='5mm',
)
content = ContentFile(pdf)
return content
def create_pdf(request):
order_id = request.GET.get('id')
order = Order.objects.get(pk=order_id)
order_html = order.generate_html()
pdf = pydf.generate_pdf(order_html, encoding='utf-8')
output_filename = os.path.join(BASE_DIR, 'pdf/checkout.pdf')
with open(output_filename, 'wb') as f:
f.write(pdf)
with open(output_filename, 'rb') as pdf_file:
response = HttpResponse(pdf_file.read())
response['Content-Type'] = 'mimetype/submimetype'
response['Content-Disposition'] = 'attachment; filename=regulation.pdf'
return response
def go_sync():
count = 10
for i in range(count):
pdf = generate_pdf(
html,
page_size='A4',
zoom='1.25',
margin_left='8mm',
margin_right='8mm',
)
print(f'{i:03}: {len(pdf)}')
file = OUT_DIR / f'output_{i:03}.pdf'
file.write_bytes(pdf)
return count
def go_sync():
count = 10
for i in range(count):
pdf = generate_pdf(
html,
page_size='A4',
zoom='1.25',
margin_left='8mm',
margin_right='8mm',
)
print(f'{i:03}: {len(pdf)}')
file = OUT_DIR / f'output_{i:03}.pdf'
file.write_bytes(pdf)
return count
def createPdf(url, size='15'):
filePath = 'files/' + url + '.txt'
try:
file = open(filePath, 'r')
pasteData = file.read()
file.close()
pdfFilePath = 'files/' + url + '.pdf'
pdf = pydf.generate_pdf('<p style="font-size:' + size + 'px">' +
pasteData + '</p>')
with open(pdfFilePath, 'wb') as f:
f.write(pdf)
f.close()
return True
except Exception as e:
print(e)
return False
def sadraft(self, request, pk=None):
session = Session.objects.get(pk=pk)
panelists = Panelist.objects.filter(
kind__in=[
Panelist.KIND.official,
Panelist.KIND.practice,
],
scores__song__appearance__round__session=session,
).select_related('person', ).distinct().order_by(
'category',
'person__last_name',
)
competitors = session.competitors.filter(
status=Competitor.STATUS.finished, ).select_related(
'group', ).prefetch_related(
'appearances',
'appearances__songs',
'appearances__songs__scores',
'appearances__songs__scores__panelist',
'appearances__songs__scores__panelist__person',
).order_by(
'-tot_points',
'-sng_points',
'-per_points',
'group__name',
)
context = {
'session': session,
'panelists': panelists,
'competitors': competitors,
}
rendered = render_to_string('sa.html', context)
file = pydf.generate_pdf(
rendered,
page_size='Letter',
orientation='Landscape',
)
content = ContentFile(file)
pdf = content
file_name = '{0}-sa'.format(
slugify("{0} {1} Session".format(
session.convention.name,
session.get_kind_display(),
)))
return PDFResponse(pdf, file_name=file_name, status=status.HTTP_200_OK)
def index():
if request.method == "GET":
return render_template("index.html")
elif request.method == "POST":
data = get_apod(request.form["date"])
if "code" in data:
return "404<br>your requested apod not found in NASA", 404
html = render_template("result.html",
title=data["title"],
date=data["date"],
image_url=data["url"],
explanation=data["explanation"])
html_footer = "</body></html>"
pdf = pydf.generate_pdf(html + html_footer)
with open("static/" + data["date"] + '.pdf', 'wb') as f:
f.write(pdf)
return html + "<center><button onclick=\"window.open('/pdf/" + data[
"date"] + ".pdf')\">Download as PDF</button></center>" + html_footer
def test_extra_arguments(self):
pdf_content = generate_pdf(
'<html><body>testing</body></html>',
quiet=False,
grayscale=True,
lowquality=True,
margin_bottom='20mm',
margin_left='20mm',
margin_right='20mm',
margin_top='20mm',
orientation='Landscape',
page_height=None,
page_width=None,
page_size='Letter',
image_dpi='300',
image_quality='70',
)
assert pdf_content[:4] == byteify('%PDF')
def render_application(request):
if request.method == "POST":
form = ApplicationForm(request.POST)
if form.is_valid():
model_instance = form.save(commit=False)
model_instance.timestamp = timezone.now()
model_instance.save()
context = model_to_dict(model_instance, fields=[field.name for field in model_instance._meta.fields])
now = datetime.datetime.now()
context["reason"] = context["reason"].lower()
context["year"] = now.year
context["day"] = now.day
context["month"] = months[now.month]
html_string = render_to_string('stud_application.html', context)
pdf = pydf.generate_pdf(html_string)
return HttpResponse(pdf, content_type='application/pdf')
else:
form = ApplicationForm()
return render(request, 'home.html', {'form': form})
def announcements(self, request, pk=None):
round = Round.objects.get(pk=pk)
appearances = round.appearances.filter(draw__gt=0, ).select_related(
'competitor__group', ).order_by('draw', )
mt = round.appearances.filter(draw=0, ).select_related(
'competitor__group', ).order_by('competitor__group__name', )
contests = round.session.contests.filter(
num__isnull=False,
group__isnull=False,
).order_by('num')
if round.kind == round.KIND.finals:
competitors = round.session.competitors.filter(
status__in=[
Competitor.STATUS.finished,
Competitor.STATUS.started,
],
tot_rank__lte=5,
).select_related('group', ).order_by('-tot_rank', )
else:
competitors = None
pos = round.appearances.aggregate(sum=Sum('pos'))['sum']
context = {
'round': round,
'appearances': appearances,
'mt': mt,
'contests': contests,
'competitors': competitors,
'pos': pos,
}
rendered = render_to_string('announcements.html', context)
file = pydf.generate_pdf(rendered)
content = ContentFile(file)
pdf = content
file_name = '{0}-announcements'.format(
slugify("{0} {1} {2} Announcements".format(
round.session.convention.name,
round.session.get_kind_display(),
round.get_kind_display(),
)))
return PDFResponse(pdf, file_name=file_name, status=status.HTTP_200_OK)
def handout_pdf(request, assignment_id):
assignment = get_object_or_404(Assignment, pk=assignment_id)
recipient = assignment.recipient
team = assignment.team
context = {
'recipient': recipient,
'team': team,
}
rendered = render_to_string('app/pdfs/handout.html', context)
pdf = pydf.generate_pdf(
rendered,
enable_smart_shrinking=False,
orientation='Portrait',
margin_top='10mm',
margin_bottom='10mm',
)
content = ContentFile(pdf)
return FileResponse(
content,
as_attachment=True,
filename='rake_up_eagle_handout.pdf',
)
def create_file(self, filetype, **kwargs):
"""Create markdown, HTML and PDF files.
Note that PDF requires a HTML input.
"""
if kwargs:
fragment = kwargs["fragment"]
dirpath = kwargs["dirpath"]
filename = kwargs["filename"]
generic_filename = "{dirpath}/{filetype}/{filename}".format(
dirpath=dirpath, filetype=filetype, filename=filename)
filepath = generic_filename + "." + filetype
image_file = "{dirpath}/images/{filename}.png".format(
dirpath=dirpath, filename=filename)
qr_image_file = self.make_qr_code(fragment)
qr_image_file.save(image_file)
d = {
'label': self.label,
'timestamp': datetime.datetime.now().strftime("%d-%b-%Y %H:%M:%S"),
'report': self.report,
'contact_name': self.config['contact']['name'],
'contact_email': self.config['contact']['email'],
'fragment': fragment,
'img_src': image_file
}
template_type = "md" if filetype == "md" else "html"
filein = open("text/fragment." + template_type)
src = Template(filein.read())
filein.close()
content = src.substitute(d)
if filetype == "pdf":
pdf = pydf.generate_pdf(content, image_quality=100, image_dpi=1000)
with open(filepath, 'wb') as f:
f.write(pdf)
else:
self.write_file(filepath, content)
def get_sung(self):
Song = apps.get_model('api.song')
appearances = self.appearances.filter(draw__gt=0, ).order_by('draw', )
for appearance in appearances:
songs = Song.objects.filter(
appearance__competitor=appearance.competitor,
).distinct().order_by(
'appearance__round__num',
'num',
)
sungs = []
for song in songs:
try:
title = song.chart.nomen
except AttributeError:
title = "Unknown (Not in Repertory)"
row = "{0} Song {1}: {2}".format(
song.appearance.round.get_kind_display(),
song.num,
title,
)
sungs.append(row)
appearance.sungs = sungs
context = {
'appearances': appearances,
'round': self,
}
rendered = render_to_string('sung.html', context)
file = pydf.generate_pdf(
rendered,
page_size='Letter',
orientation='Portrait',
margin_top='5mm',
margin_bottom='5mm',
)
content = ContentFile(file)
return content
def handout_pdfs(request):
assignments = Assignment.objects.order_by('team__name', )
output = ''
for assignment in assignments:
context = {
'recipient': assignment.recipient,
'team': assignment.team,
}
rendered = render_to_string('app/pdfs/handout.html', context)
output += '<div class="new-page"></div>' + rendered
pdf = pydf.generate_pdf(
output,
enable_smart_shrinking=False,
orientation='Portrait',
margin_top='10mm',
margin_bottom='10mm',
)
content = ContentFile(pdf)
return FileResponse(
content,
as_attachment=True,
filename='handouts.pdf',
)
def get_csa(self):
Panelist = apps.get_model('api.panelist')
Song = apps.get_model('api.song')
Score = apps.get_model('api.score')
# Appearancers Block
group = self.group
stats = Score.objects.select_related(
'song__appearance__group',
'song__appearance__round__session',
'song__appearance__round',
'panelist',
).filter(
song__appearance__group=self.group,
song__appearance__round__session=self.round.session,
panelist__kind=Panelist.KIND.official,
).aggregate(
max=Max(
'song__appearance__round__num',
),
tot_points=Sum(
'points',
),
mus_points=Sum(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.music,
)
),
per_points=Sum(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.performance,
)
),
sng_points=Sum(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.singing,
)
),
tot_score=Avg(
'points',
),
mus_score=Avg(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.music,
)
),
per_score=Avg(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.performance,
)
),
sng_score=Avg(
'points',
filter=Q(
panelist__category=Panelist.CATEGORY.singing,
)
),
)
appearances = Appearance.objects.select_related(
'group',
'round',
'round__session',
).prefetch_related(
'songs__scores',
'songs__scores__panelist',
).filter(
group=self.group,
round__session=self.round.session,
).annotate(
tot_points=Sum(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
),
),
mus_points=Sum(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.music,
),
),
per_points=Sum(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.performance,
),
),
sng_points=Sum(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.singing,
),
),
tot_score=Avg(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
),
),
mus_score=Avg(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.music,
),
),
per_score=Avg(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.performance,
),
),
sng_score=Avg(
'songs__scores__points',
filter=Q(
songs__scores__panelist__kind=Panelist.KIND.official,
songs__scores__panelist__category=Panelist.CATEGORY.singing,
),
),
)
# Monkeypatch
for key, value in stats.items():
setattr(group, key, value)
for appearance in appearances:
songs = appearance.songs.prefetch_related(
'scores',
'scores__panelist',
).order_by(
'num',
).annotate(
tot_score=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
),
),
mus_score=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.music,
),
),
per_score=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.performance,
),
),
sng_score=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.singing,
),
),
tot_points=Sum(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
),
),
mus_points=Sum(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.music,
),
),
per_points=Sum(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.performance,
),
),
sng_points=Sum(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.singing,
),
),
)
for song in songs:
penalties_map = {
10: "†",
30: "‡",
40: "✠",
50: "✶",
}
items = " ".join([penalties_map[x] for x in song.penalties])
song.penalties_patched = items
appearance.songs_patched = songs
group.appearances_patched = appearances
# Panelists
panelists = Panelist.objects.select_related(
'person',
).filter(
kind=Panelist.KIND.official,
round__session=self.round.session,
round__num=1,
category__gt=10,
).order_by('num')
# Score Block
initials = [x.person.initials for x in panelists]
# Hackalicious
category_count = {
'Music': 0,
'Performance': 0,
'Singing': 0,
}
for panelist in panelists:
category_count[panelist.get_category_display()] += 1
songs = Song.objects.filter(
appearance__round__session=self.round.session,
appearance__group=self.group,
).order_by(
'appearance__round__kind',
'num',
)
for song in songs:
scores = song.scores.filter(
panelist__kind=Panelist.KIND.official,
).order_by('panelist__num')
class_map = {
Panelist.CATEGORY.music: 'warning',
Panelist.CATEGORY.performance: 'success',
Panelist.CATEGORY.singing: 'info',
}
items = []
for score in scores:
items.append((score.points, class_map[score.panelist.category]))
song.scores_patched = items
# Category Block
categories = {
'Music': [],
'Performance': [],
'Singing': [],
}
# panelists from above
for panelist in panelists:
item = categories[panelist.get_category_display()]
item.append(panelist.person.common_name)
# Penalties Block
array = Song.objects.filter(
appearance__round__session=self.round.session,
appearance__group=self.group,
penalties__len__gt=0,
).distinct().values_list('penalties', flat=True)
penalties_map = {
10: "† Score(s) penalized due to violation of Article IX.A.1 of the BHS Contest Rules.",
30: "‡ Score(s) penalized due to violation of Article IX.A.2 of the BHS Contest Rules.",
40: "✠ Score(s) penalized due to violation of Article IX.A.3 of the BHS Contest Rules.",
50: "✶ Score(s) penalized due to violation of Article X.B of the BHS Contest Rules.",
}
penalties = sorted(list(set(penalties_map[x] for l in array for x in l)))
context = {
'appearance': self,
'round': self.round,
'group': group,
'initials': initials,
'songs': songs,
'categories': categories,
'penalties': penalties,
'category_count': category_count,
}
rendered = render_to_string(
'reports/csa.html',
context,
)
statelog = self.round.statelogs.latest('timestamp')
footer = 'Published by {0} at {1}'.format(
statelog.by,
statelog.timestamp.strftime("%Y-%m-%d %H:%M:%S %Z"),
)
file = pydf.generate_pdf(
rendered,
orientation='Portrait',
margin_top='5mm',
margin_bottom='5mm',
footer_right=footer,
footer_font_name='Encode Sans',
footer_font_size=8,
)
content = ContentFile(file)
return content
def test_extra_kwargs(self):
pdf_content = generate_pdf(
'<html><body>testing</body></html>',
header_right='Page [page] of [toPage]'
)
assert pdf_content[:4] == byteify('%PDF')
def test_bad_arguments():
with pytest.raises(RuntimeError) as exc_info:
generate_pdf('hello', foobar='broken')
assert 'error running wkhtmltopdf, command' in str(exc_info)
def test_generate_pdf_with_html():
pdf_content = generate_pdf('<html><body>Is this thing on?</body></html>')
assert pdf_content[:4] == b'%PDF'
text = pdf_text(pdf_content)
assert 'Is this thing on?\n\n\x0c' == text
def test_unicode(self):
pdf_content = generate_pdf(u'<html><body>Schrödinger</body></html>')
assert pdf_content[:4] == byteify('%PDF')
def test_generate_pdf_with_url(self):
pdf_content = generate_pdf('http://google.com')
assert pdf_content[:4] == byteify('%PDF')
def test_generate_pdf_with_html(self):
pdf_content = generate_pdf('<html><body>Is this thing on?</body></html>')
assert pdf_content[:4] == byteify('%PDF')
def get_psa(self):
Score = apps.get_model('api.score')
Group = apps.get_model('bhs.group')
# Score block
group_ids = self.round.appearances.exclude(
# Don't include advancers or MTs on PSA
draw__gt=0,
).values_list('group__id', flat=True)
groups = Group.objects.filter(
id__in=group_ids,
).prefetch_related(
'appearances__songs__scores',
'appearances__songs__scores__panelist',
'appearances__round__session',
).annotate(
tot_points=Sum(
'appearances__songs__scores__points',
filter=Q(
appearances__songs__scores__panelist__kind=Panelist.KIND.official,
appearances__round__session=self.round.session,
),
),
per_points=Sum(
'appearances__songs__scores__points',
filter=Q(
appearances__songs__scores__panelist__kind=Panelist.KIND.official,
appearances__songs__scores__panelist__category=Panelist.CATEGORY.performance,
appearances__round__session=self.round.session,
),
),
sng_points=Sum(
'appearances__songs__scores__points',
filter=Q(
appearances__songs__scores__panelist__kind=Panelist.KIND.official,
appearances__songs__scores__panelist__category=Panelist.CATEGORY.singing,
appearances__round__session=self.round.session,
),
),
).order_by(
'-tot_points',
'-sng_points',
'-per_points',
)
# Monkeypatching
class_map = {
Panelist.CATEGORY.music: 'badge badge-warning mono-font',
Panelist.CATEGORY.performance: 'badge badge-success mono-font',
Panelist.CATEGORY.singing: 'badge badge-info mono-font',
}
for group in groups:
appearances = group.appearances.filter(
round__session=self.round.session,
).order_by('round__kind')
for appearance in appearances:
songs = appearance.songs.order_by(
'num',
).prefetch_related(
'scores',
'scores__panelist',
).annotate(
avg=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
),
),
dev=StdDev(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
),
),
Music=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.music,
),
),
Performance=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.performance,
),
),
Singing=Avg(
'scores__points',
filter=Q(
scores__panelist__kind=Panelist.KIND.official,
scores__panelist__category=Panelist.CATEGORY.singing,
),
),
)
for song in songs:
scores2 = song.scores.select_related(
'panelist',
).filter(
panelist__kind=Panelist.KIND.official,
).order_by('points')
out = []
for score in scores2:
if score.points == 0:
score.points = "00"
span_class = class_map[score.panelist.category]
if score.panelist.person == self.person:
span_class = "{0} black-font".format(span_class)
out.append((score.points, span_class))
song.scores_patched = out
panelist_score = song.scores.get(
panelist__person=self.person,
)
category = self.get_category_display()
diff = panelist_score.points - getattr(song, category)
song.diff_patched = diff
pp = song.scores.get(panelist__person=self.person).points
song.pp = pp
appearance.songs_patched = songs
group.appearances_patched = appearances
context = {
'panelist': self,
'groups': groups,
}
rendered = render_to_string(
'reports/psa.html',
context,
)
statelog = self.round.statelogs.latest('timestamp')
footer = 'Published by {0} at {1}'.format(
statelog.by,
statelog.timestamp.strftime("%Y-%m-%d %H:%M:%S %Z"),
)
file = pydf.generate_pdf(
rendered,
page_size='Letter',
orientation='Portrait',
margin_top='5mm',
margin_bottom='5mm',
footer_right=footer,
footer_font_name='Encode Sans',
footer_font_size=8,
)
content = ContentFile(file)
return content
