def vir_typer_results(request, vir_typer_pk): from django.core.files.storage import FileSystemStorage from django.http import HttpResponse from django.template.loader import render_to_string import datetime manager_codes = { 'NOVI': { 'code': 'NOV1-SEQ', 'comments_en': 'Norovirus genogroup I was confirmed by gene sequencing of the amplicon.', 'comments_fr': 'Le séquençage de l\'amplicon confirme la présence du Norovirus génogroup I.' }, 'NOVII': { 'code': 'NOV2-SEQ', 'comments_en': 'Norovirus genogroup II was confirmed by gene sequencing of the amplicon.', 'comments_fr': 'Le séquençage de l\'amplicon confirme la présence du Norovirus génogroup II.' }, 'HAV': { 'code': 'HAV-SEQ', 'comments_en': 'Hepatitis A was confirmed by gene sequencing of the amplicon.', 'comments_fr': 'Le séquençage de l\'amplicon confirme la présence du Hepatitis A.' }, 'MNV': { 'code': 'MNV-SEQ', 'comments_en': 'Murine norovirus was confirmed by gene sequencing of the amplicon.', 'comments_fr': 'Le séquençage de l\'amplicon confirme la présence du Murine norovirus.' }, } vir_typer_project = get_object_or_404(VirTyperProject, pk=vir_typer_pk) vir_typer_samples = list( VirTyperRequest.objects.filter(project_name__pk=vir_typer_pk)) vir_typer_result = list() parse = False for sample in vir_typer_samples: vir_files = list( VirTyperFiles.objects.filter(sample_name__pk=sample.pk)) for vir_file in vir_files: try: vir_typer_result.append( VirTyperResults.objects.get(sequence_file__pk=vir_file.pk)) except: parse = True # Parse the JSON report, and enter the results into the database if necessary if parse: parse_report(vir_typer_json=vir_typer_project.report, vir_typer_samples=vir_typer_samples) vir_typer_samples = list( VirTyperRequest.objects.filter(project_name__pk=vir_typer_pk)) pn = vir_typer_project.project_name vir_files = list() full_results = dict() full_results['data'] = list() codes = set() alleles = dict() outputs = list() samples = list() for sample in VirTyperRequest.objects.filter( project_name__pk=vir_typer_pk): samples.append(sample.sample_name) for sorted_sample in sorted(samples): for sample in VirTyperRequest.objects.filter( project_name__pk=vir_typer_pk): if sample.sample_name == sorted_sample: sequences = list() sample_dict = dict() sample_dict['sample_project'] = pn sample_dict['sample_name'] = sample.sample_name sample_dict['lsts'] = sample.LSTS_ID sample_dict['date_received'] = '{:%Y-%m-%d}'.format( sample.date_received) sample_dict['isolate_source'] = sample.isolate_source sample_dict['organism'] = sample.putative_classification try: codes.add( (sample.putative_classification, manager_codes[sample.putative_classification]['code'], manager_codes[sample.putative_classification] ['comments_en'], manager_codes[ sample.putative_classification]['comments_fr'])) except KeyError: pass sample_dict['identifier'] = list() sample_dict['allele'] = list() sample_dict['sequence'] = list() sample_dict['sequence_length'] = list() sample_dict['variable_locations'] = list() sample_dict['mean_quality'] = list() sample_dict['stdev_quality'] = list() alleles[sample.sample_name] = set() for vir_file in VirTyperFiles.objects.filter( sample_name__pk=sample.pk): vir_files.append(vir_file) seq_identifier_well = str( os.path.splitext( vir_file.sequence_file)[0].split('_')[-2]) seq_identifier_num = os.path.splitext( vir_file.sequence_file)[0].split('_')[-1] seq_identifier_code = '_'.join( (seq_identifier_well, seq_identifier_num)) sample_dict['identifier'].append(seq_identifier_code + '\n') result = VirTyperResults.objects.filter( sequence_file__pk=vir_file.pk) for vir_typer_result in result: sample_dict['allele'].append(vir_typer_result.allele + '\n') alleles[sample.sample_name].add( vir_typer_result.allele) sequences.append({ sample.sample_name + '_' + seq_identifier_code: vir_typer_result.trimmed_sequence }) sample_dict['sequence_length'].append( vir_typer_result.trimmed_sequence_len + '\n') sample_dict['mean_quality'].append( vir_typer_result.trimmed_quality_mean) sample_dict['stdev_quality'].append( vir_typer_result.trimmed_quality_stdev) consensus_sequence = sequence_consensus( sequences, vir_typer_pk) for vir_file in VirTyperFiles.objects.filter( sample_name__pk=sample.pk): result = VirTyperResults.objects.filter( sequence_file__pk=vir_file.pk) for vir_typer_result in result: html_string, variable_locations = sequence_html_string( vir_typer_result.trimmed_sequence, consensus_sequence) sample_dict['variable_locations'].append( variable_locations) sample_dict['sequence'].append(html_string + '\n') full_results['data'].append(sample_dict) outputs.append(sample_dict) json_path = 'olc_webportalv2/static/ajax/vir_typer/{pk}/arrays.txt'.format( pk=vir_typer_pk) data_tables_path = '../../../../static/ajax/vir_typer/{pk}/arrays.txt'.format( pk=vir_typer_pk) os.makedirs( 'olc_webportalv2/static/ajax/vir_typer/{pk}'.format(pk=vir_typer_pk), exist_ok=True) os.makedirs('olc_webportalv2/media/vir_typer/{pk}'.format(pk=vir_typer_pk), exist_ok=True) # Create the JSON-formatted output file with open(json_path, 'w') as json_out: json.dump(full_results, json_out) if request.method == 'POST': # Create a string of the HTML output using the appropriate template and variables html_string = render_to_string( 'vir_typer/vir_typer_results_to_pdf.html', { 'vir_typer_project': vir_typer_project, 'date': '{:%Y-%m-%d}'.format(datetime.datetime.now()), 'codes': sorted(list(codes)), 'results': outputs, 'vir_typer_samples': vir_typer_samples, }) # Create an HTML object from the HTML string html = HTML(string=html_string, base_url=request.build_absolute_uri()) # Set the links to the CSS files bootstrap_css = CSS( filename='olc_webportalv2/static/css/bootstrap.min.css') project_css = CSS(filename='olc_webportalv2/static/css/project.css') all_css = CSS(filename='olc_webportalv2/static/fonts/css/all.css') # Create a custom CSS string to make the page letter sized, with landscape orientation page_css = CSS(string='@page { size: Letter landscape; margin: 1cm }') # html.write_pdf( target= 'olc_webportalv2/media/vir_typer/{pk}/VirusTyperReport_{pn}.pdf'. format(pk=vir_typer_pk, pn=vir_typer_project.project_name), stylesheets=[bootstrap_css, project_css, all_css, page_css], presentational_hints=True) # Download fs = FileSystemStorage( 'olc_webportalv2/media/vir_typer/{pk}/'.format(pk=vir_typer_pk)) with fs.open("VirusTyperReport_{pn}.pdf".format( pn=vir_typer_project.project_name)) as pdf: response = HttpResponse(pdf, content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename="VirusTyperReport_{pn}.pdf"'\ .format(pn=vir_typer_project.project_name) return response return render( request, 'vir_typer/vir_typer_results.html', { 'vir_typer_project': vir_typer_project, 'date': '{:%Y-%m-%d}'.format(datetime.datetime.now()), 'codes': sorted(list(codes)), 'json_results': data_tables_path, 'results': outputs, 'vir_typer_samples': vir_typer_samples, 'vir_typer_files': vir_files, })
from weasyprint import HTML # Adapted from: https://github.com/Kozea/WeasyPrint/issues/23#issuecomment-312447974 # def generate_outline_str(bookmarks, indent=0): # outline_str = "" # for i, (label, (page, _, _), children) in enumerate(bookmarks, 1): # outline_str += ('%s%d. %s (page %d)' % ( # ' ' * indent, i, label.lstrip('0123456789. '), page)) # outline_str += generate_outline_str(children, indent + 2) # return outline_str document = HTML('rules/RULES.html').render() # table_of_contents_string = generate_outline_str(document.make_bookmark_tree()) # table_of_contents_document = HTML(string=table_of_contents_string).render() # table_of_contents_page = table_of_contents_document.pages[0] # document.pages.insert(0, table_of_contents_page) document.write_pdf('_output/RULES.pdf')
def OdenPDF(request, id): from django.http import HttpResponse from django.template.loader import render_to_string from django.utils.text import slugify from django.contrib.auth.decorators import login_required from weasyprint import HTML from weasyprint.fonts import FontConfiguration from weasyprint import CSS compra = OrdenCabecera.objects.get(id=id) item = OrdenCompraBody.objects.filter(CompraHead=compra.id) prove = get_object_or_404(Proveedor, id=compra.Proveedor.id) produc = Producto.objects.filter(ProveedorItem=prove.id) sum = 0 for a in item: total = a.Item.PrecioCompra * a.Cantidad sum = sum + total #response = HttpResponse(content_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document") response = HttpResponse(content_type="application/pdf") # response['Content-Disposition'] = "attachment; response[ 'Content-Disposition'] = "attachment; filename=ODE.{}.{}.{}.pdf".format( compra.FechaCreacion.year, str(compra.ContSerializeQtn).zfill(4), str(compra.SerializeQtn).zfill(2)) font_config = FontConfiguration() html = render_to_string( "vil/tpl/ordendecompra.html", { 'compra': compra, 'Item': item, 'request': request, 'prove': prove, "subtotal": sum }) css = CSS(string=''' @page { @bottom-center { content: string(title); font-size:12px; border-top:1px solid black; color:#186a43; width:100%; height:50px; } } header { width: 0; height: 0; visibility: hidden; string-set: title content(); } @font-face { font-family: "calibrilight"; } body{ font-family: 'calibrilight'; font-size: 12px; }''', font_config=font_config) HTML(string=html).write_pdf(response, stylesheets=[css], font_config=font_config) return response
def render_template(url): parts = [ '''\ <!doctype html> <meta charset=utf-8> <title>WeasyPrint Navigator</title> <style> form { position: fixed; z-index: 1; top: 8px; left: 16px; right: 0; } nav, input { font: 24px/30px sans-serif } input:not([type]) { background: rgba(255, 255, 255, .9); border-width: 2px; border-radius: 6px; padding: 0 3px } input:not([type]):focus { outline: none } body { margin-top: 0; padding-top: 50px } section { box-shadow: 0 0 10px 2px #aaa; margin: 25px; position: relative; overflow: hidden; } section a { position: absolute; display: block } section a[href]:hover, a[href]:focus { outline: 1px dotted } nav { margin: 25px } </style> <body onload="var u=document.forms[0].url; u.value || u.focus()"> <form action="/" onsubmit=" window.location.href = '/view/' + this.url.value; return false;"> <input name=url style="width: 80%" placeholder="Enter an URL to start" value="''' ] write = parts.append if url: html = HTML(url) url = html.base_url write(url) write('" />\n<input type=submit value=Go />\n') if url: write('<a href="/pdf/') write(url) write('">PDF</a>\n') write('</form>\n') if url: for width, height, data_url, links, anchors in get_pages(html): write('<section style="width: {0}px; height: {1}px">\n' ' <img src="{2}">\n'.format(width, height, data_url)) for link_type, target, (pos_x, pos_y, width, height) in links: href = ('#' + target if link_type == 'internal' else '/view/' + target) write(' <a style="left: {0}px; top: {1}px; ' 'width: {2}px; height: {3}px" href="{4}"></a>\n'.format( pos_x, pos_y, width, height, href)) for anchor_name, (pos_x, pos_y) in anchors.items(): # Remove 60px to pos_y so that the real pos is below # the address bar. write( ' <a style="left: {0}px; top: {1}px;" name="{2}"></a>\n'. format(pos_x, pos_y - 60, anchor_name)) write('</section>\n') else: write(''' <nav> <h2>Examples:</h2> <ul> <li><a href="/view/http://www.webstandards.org/files/acid2/test.html"> Acid2</a></li> <li><a href="/view/http://www.w3.org/Style/CSS/current-work"> CSS specifications</a></li> <li><a href="/view/http://en.wikipedia.org/"> English Wikipedia</a></li> </ul> </nav> ''') return ''.join(parts).encode('utf8')
def html_generator(manillas: list, template: str, eb: str): '''Generate the html of the qr and values list to further convert to pdf''' file_loader = FileSystemLoader('./') env = Environment(loader=file_loader) template = env.get_template(template) for manilla in manillas: manilla["qr"].save('output/qrs/' + str(manilla["data"]) + '.png') result = template.render(manillas=manillas, eb=eb) return result # Ask for input num_manillas = input("Número de Manillas: ") eb = input("Estudio Bíblico: ") output = eb.lower() template = 'templates/template.html' data = random_data(int(num_manillas), 5000000, 6000000) qrs = qr_generator(data) manillas = html_generator(qrs, template=template, eb=eb) with open(output + '.html', 'w') as file: file.write(manillas) with open(eb.lower() + '.txt', 'w') as file: for item in data: file.write(f"{item}\n") HTML(filename=output + '.html').write_pdf(output + '.pdf')
from django.test import TestCase from weasyprint import HTML from weasyprint.fonts import FontConfiguration from jinja2 import Environment, FileSystemLoader # load template env = Environment(loader=FileSystemLoader('.')) template = env.get_template('./templates/creator/certificate.html') # render template rendered = template.render(messages=['Hello','World']) # write to PDF HTML(string=rendered).write_pdf('weasyprint_jinja2_spike_output.pdf') # Create your tests here.
ydl.download([toDownload[i].url]) print('youtube-dl supported!' + toDownload[i].id) except Exception as e: Unable.write( str(e) + ' ' + toDownload[i].url + ' http://www.reddit.com/' + toDownload[i].id + '\n') else: print('ytdl exists! ' + toDownload[i].id) os.chdir(base) elif bool(toDownload[i].is_self): if not os.path.isfile(mypath + '/' + toDownload[i].id + '.pdf'): if not bool(toDownload[i].over_18): HTML(toDownload[i].url.replace( 'www', 'old')).write_pdf(mypath + '/' + toDownload[i].id + '.pdf') elif bool( re.search('reddit\.com/gallery', toDownload[i].url, re.IGNORECASE)): print('Reddit album!') response = requests.get(toDownload[i].url, headers=headers) soup = BeautifulSoup(response.text, 'lxml') img = soup.find_all('a', {'rel': 'noopener noreferrer'}) if not (os.path.isdir(mypath + '/' + toDownload[i].id + '/')): os.makedirs(mypath + '/' + toDownload[i].id + '/') for g, image in enumerate(img): download( image['href'], mypath + '/' + toDownload[i].id + '/' +
from weasyprint import HTML import logging logging.basicConfig(level=logging.DEBUG) URL = "http://tools.hde.nl/menc/site/guides/Pliss%C3%A9%20%26%20Duette%C2%AE%20Bottom-Up%20programming/" OUT = "/home/admin-s/test.pdf" for lp in range(0, 300): try: HTML(URL).write_pdf(OUT) except OSError as e: logging.exception( "**************** ERROR AT ATTEMPT: {} *******************".format( lp)) break
def get_pdf(filename): html_file = "./html/{}.html".format(filename) pdf_file = "./pdf/{}.pdf".format(filename) HTML(html_file).write_pdf(pdf_file) print("Done")
def generate_report(url, username, password, component_key): server_version = get_string(url, username, password, "/api/server/version") json_data = get_json( url, username, password, "/api/navigation/component?componentKey=" + component_key) project_name = json_data["name"] project_organization = json_data["organization"] project_quality_gate = json_data["qualityGate"] project_quality_profiles = json_data["qualityProfiles"] project_analysis_date = dateutil.parser.parse(json_data["analysisDate"]) project_analysis_date_utc = str( datetime.datetime.utcfromtimestamp( project_analysis_date.timestamp())) + " UTC" project_version = json_data["version"] quality_gates_table = "" if project_quality_gate: quality_gates_table += "<table><tr><th>Key</th><th>Name</th><th>Is Default</th></tr>" if 'key' in project_quality_gate: quality_gates_table += "<td>" + str( project_quality_gate['key']) + "</td>" else: quality_gates_table += "<td></td>" if 'name' in project_quality_gate: quality_gates_table += "<td>" + project_quality_gate[ 'name'] + "</td>" else: quality_gates_table += "<td></td>" if 'isDefault' in project_quality_gate: quality_gates_table += "<td>" + str( project_quality_gate['isDefault']) + "</td>" else: quality_gates_table += "<td></td>" quality_gates_table += "</table>" quality_profiles_table = "" if len(project_quality_profiles) > 0: quality_profiles_table += "<table><tr><th>Key</th><th>Name</th><th>Language</th></tr>" for quality_profile in project_quality_profiles: quality_profiles_table += "<tr>" if 'key' in quality_profile: quality_profiles_table += "<td>" + quality_profile[ 'key'] + "</td>" else: quality_profiles_table += "<td></td>" if 'name' in quality_profile: quality_profiles_table += "<td>" + quality_profile[ 'name'] + "</td>" else: quality_profiles_table += "<td></td>" if 'language' in quality_profile: quality_profiles_table += "<td>" + quality_profile[ 'language'] + "</td>" else: quality_profiles_table += "<td></td>" quality_profiles_table += "</tr>" quality_profiles_table += "</table>" json_data = get_json( url, username, password, "/api/measures/component?additionalFields=metrics%2Cperiods&componentKey=" + component_key + "&metricKeys=alert_status%2Cquality_gate_details%2Cbugs%2Cnew_bugs%2Creliability_rating%2Cnew_reliability_rating%2Cvulnerabilities%2Cnew_vulnerabilities%2Csecurity_rating%2Cnew_security_rating%2Ccode_smells%2Cnew_code_smells%2Csqale_rating%2Cnew_maintainability_rating%2Csqale_index%2Cnew_technical_debt%2Ccoverage%2Cnew_coverage%2Cnew_lines_to_cover%2Ctests%2Cduplicated_lines_density%2Cnew_duplicated_lines_density%2Cduplicated_blocks%2Cncloc%2Cncloc_language_distribution%2Cprojects%2Cnew_lines" ) measures = json_data['component']['measures'] periods = json_data["periods"] metrics = json_data["metrics"] quality_gate_status = get_value_for_metric_key("alert_status", measures) if quality_gate_status == "ERROR": quality_gate_status = "Failed" bugs = get_value_for_metric_key("bugs", measures) vulnerabilities = get_value_for_metric_key("vulnerabilities", measures) security_rating = get_value_for_metric_key("security_rating", measures) code_smells = get_value_for_metric_key("code_smells", measures) coverage = get_value_for_metric_key("coverage", measures) duplicated_blocks = get_value_for_metric_key("duplicated_blocks", measures) duplicated_lines_density = get_value_for_metric_key( "duplicated_lines_density", measures) ncloc = get_value_for_metric_key("ncloc", measures) ncloc_language_distribution = get_value_for_metric_key( "ncloc_language_distribution", measures) reliability_rating = get_value_for_metric_key("reliability_rating", measures) sqale_index = get_value_for_metric_key("sqale_index", measures) sqale_rating = get_value_for_metric_key("sqale_rating", measures) period_index = 0 period_details_table = "" if len(periods) > 0: period = periods[period_index] period_since = "previous version" if "parameter" in period: period_since = period["parameter"] else: if "mode" in period: period_since = period["mode"] period_started = period["date"] new_bugs = get_value_for_metric_key_and_period_index( "new_bugs", measures, period_index) new_vulnerabilities = get_value_for_metric_key_and_period_index( "new_vulnerabilities", measures, period_index) new_security_rating = get_value_for_metric_key_and_period_index( "new_security_rating", measures, period_index) new_code_smells = get_value_for_metric_key_and_period_index( "new_code_smells", measures, period_index) new_lines = get_value_for_metric_key_and_period_index( "new_lines", measures, period_index) new_lines_to_cover = get_value_for_metric_key_and_period_index( "new_lines_to_cover", measures, period_index) new_reliability_rating = get_value_for_metric_key_and_period_index( "new_reliability_rating", measures, period_index) new_technical_debt = get_value_for_metric_key_and_period_index( "new_technical_debt", measures, period_index) new_maintainability_rating = get_value_for_metric_key_and_period_index( "new_maintainability_rating", measures, period_index) period_details_table += "<h3>Leak Period: since " + period_since + ", started " + period_started + "</h3>" period_details_table += "<table><tr><th>Issue Type</th><th>Value</th></tr>" period_details_table += "<tr><td>New Bugs</td><td>" + new_bugs + "</td></tr>" period_details_table += "<tr><td>New Vulnerabilities</td><td>" + new_vulnerabilities + "</td></tr>" period_details_table += "<tr><td>Security Rating on New Code</td><td>" + new_security_rating + "</td></tr>" period_details_table += "<tr><td>New Code Smells</td><td>" + new_code_smells + "</td></tr>" period_details_table += "<tr><td>New Lines</td><td>" + new_lines + "</td></tr>" period_details_table += "<tr><td>Lines to Cover on New Code</td><td>" + new_lines_to_cover + "</td></tr>" period_details_table += "<tr><td>Reliability Rating on New Code</td><td>" + new_reliability_rating + \ "</td></tr>" period_details_table += "<tr><td>Added Technical Debt</td><td>" + new_technical_debt + "</td></tr>" period_details_table += "<tr><td>Maintainability Rating on New Code</td><td>" + new_maintainability_rating + \ "</td></tr>" period_details_table += "</table><br>" quality_gate_details = get_value_for_metric_key("quality_gate_details", measures) quality_gate_details_table = "" if quality_gate_details: conditions = json.loads(quality_gate_details)["conditions"] if len(conditions) > 0: quality_gate_details_table += "<table><tr><th>Metric</th><th>Actual Value</th><th>Operand</th>" \ "<th>Expected Value</th></tr>" for condition in conditions: quality_gate_details_table += "<tr>" if 'level' in condition and condition['level'] == "ERROR": if 'metric' in condition: metric_name = get_name_for_metric_key( condition['metric'], metrics) quality_gate_details_table += "<td>" + metric_name + "</td>" else: quality_gate_details_table += "<td></td>" if 'actual' in condition: quality_gate_details_table += "<td>" + condition[ 'actual'] + "</td>" else: quality_gate_details_table += "<td></td>" if 'op' in condition: quality_gate_details_table += "<td>" + condition[ 'op'] + "</td>" else: quality_gate_details_table += "<td></td>" if 'error' in condition: quality_gate_details_table += "<td>" + condition[ 'error'] + "</td>" else: quality_gate_details_table += "<td></td>" quality_gate_details_table += "</tr></table>" json_data = get_json( url, username, password, "/api/issues/search?componentKeys=" + component_key + "&statuses=OPEN&ps=1") if json_data['total'] == 0: print("no data returned - no report will be generated") else: print("found " + str(json_data['total']) + " issues. Report will be generated...") json_all = "[" # GET ALL ISSUES (max. 500) OF TYPE VULNERABILITY json_vulnerabilities = get_json( url, username, password, "/api/issues/search?componentKeys=" + component_key + "&statuses=OPEN&ps=500&types=VULNERABILITY") if json_vulnerabilities['total'] > 0: print("found " + str(json_vulnerabilities['total']) + " issues of type VULNERABILITY") json_vulnerabilities = filter_json(json_vulnerabilities) json_all += json_vulnerabilities # GET ALL ISSUS (max. 500) OF TYPE BUG json_bugs = get_json( url, username, password, "/api/issues/search?componentKeys=" + component_key + "&statuses=OPEN&ps=500&types=BUG") if json_bugs['total'] > 0: print("found " + str(json_bugs['total']) + " issues of type BUG") json_bugs = filter_json(json_bugs) if json_all != "[": json_all += "," json_all += json_bugs # GET ALL ISSUES (max. 500) OF TYPE CODE_SMELL json_codesmells = get_json( url, username, password, "/api/issues/search?componentKeys=" + component_key + "&statuses=OPEN&ps=500&types=CODE_SMELL") if json_codesmells['total'] > 0: print("found " + str(json_codesmells['total']) + " issues of type CODE_SMELL") json_codesmells = filter_json(json_codesmells) if json_all != '[': json_all += "," json_all += json_codesmells json_all += "]" # GENERATE PDF json_data = json.loads(json_all) html_issues = "" for i in json_data: html_issues += "<tr>" if 'type' in i: html_issues += "<td>" + i['type'] + "</td>" else: html_issues += "<td></td>" if 'component' in i: component = i['component'] component = component.split(":")[-1] html_issues += "<td>" + component + "</td>" else: html_issues += "<td></td>" if 'startLine' in i: html_issues += "<td>" + str(i['startLine']) + "</td>" else: html_issues += "<td></td>" if 'endLine' in i: html_issues += "<td>" + str(i['endLine']) + "</td>" else: html_issues += "<td></td>" if 'message' in i: html_issues += "<td>" + i['message'] + "</td>" else: html_issues += "<td></td>" html_issues += "</tr>" now_in_utc = datetime.datetime.utcfromtimestamp( datetime.datetime.now().timestamp()) creation_date = str(now_in_utc) + " UTC" env = Environment(loader=FileSystemLoader('.')) template = env.get_template(TEMPLATE) template_vars = { "project": component_key, "server_version": server_version, "creation_date": creation_date, "quality_gate_status": quality_gate_status, "bugs": bugs, "vulnerabilities": vulnerabilities, "security_rating": security_rating, "code_smells": code_smells, "coverage": coverage, "duplicated_blocks": duplicated_blocks, "duplicated_lines_density": duplicated_lines_density, "ncloc": ncloc, "ncloc_language_distribution": ncloc_language_distribution, "reliability_rating": reliability_rating, "sqale_index": sqale_index, "sqale_rating": sqale_rating, "issue_table": html_issues, "quality_gate_details_table": quality_gate_details_table, "project_name": project_name, "project_organization": project_organization, "project_version": project_version, "quality_gates_table": quality_gates_table, "quality_profiles_table": quality_profiles_table, "project_analysis_date": project_analysis_date_utc } html_out = template.render(template_vars) report_name = "sonarqube_report_" + project_name + "_" + now_in_utc.strftime( "%Y%m%d%H%M%S") + ".pdf" HTML(string=html_out, base_url=".").write_pdf(report_name, stylesheets=["style.css"])
def render(cat_image, background_image, text): ugly_text = uglify(text) font = random.choice(fonts) color = random.choice(colors) pixabay_logo = os.path.join(os.getcwd(), 'spreukbot/pixabay-logo.png') cat_url, cat_width, cat_height = cat_image bg_url, bg_width, bg_height = background_image demo_page = f''' data:text/html, <!doctype html> <html> <head> <meta charset="utf-8"> <title>LOL</title> <link href="https://fonts.googleapis.com/css?family=Pacifico|Baloo+Tamma|Merriweather|Poiret+One" rel="stylesheet"> <style> @page {{ margin: 0; size: {cat_width * 3}px {cat_height}px; }} * {{ padding: 0; margin: 0; text-shadow: #FC0 1px 0 10px; }} html, body {{ text-align: center; padding: 0; }} body:before {{ content: ""; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-size: cover; background-image: url('{bg_url.replace('https://pixabay.com', 'http://spreukbot-pixabay.barkr.uk')}'); background-repeat: no-repeat; }} p {{ position: absolute; top: 0; left: 0; width: 100%; height: 100%; font-family: {font}; font-size: 32px; color: {color}; text-stroke: 2px white; }} p.shadow {{ color: black !important; top: 1px; left: 1px; }} div.watermark {{ position: absolute; right: 10%; bottom: 10%; transform: rotate(-45deg); opacity: .2; width: 20%; }} img.pixabay {{ position: absolute; right: 0; top: 0; }} </style> </head> <body> <p>text</p> <div class="watermark"> Wijze spreuken om te delen van Marko V. Keten </div <img class="pixabay" src="cat_url"> </body> </html> ''' from weasyprint import HTML from weasyprint.logger import LOGGER as weasyprint_logger import logging logging.getLogger('weasyprint').setLevel(logging.DEBUG) weasyprint_logger.addFilter(WeasyprintLoggerFilter()) weasyprint_logger.setLevel(logging.DEBUG) data = HTML(string=demo_page).write_png() return data
def document_png(): # We didn’t bother to make a ``render_png`` helper # but of course you can still use WeasyPrint’s PNG output. return Response(HTML('/').write_png(), mimetype='image/png')
def generar_pdf(self, request, orden_examen): if not orden_examen.especial: multifirma = OrdenExamen.objects.select_related( 'examen', 'examen__subgrupo_cups').prefetch_related( 'mis_firmas', 'mis_firmas__especialista', 'mis_firmas__especialista__especialidad', ).annotate(can_firmas=Count("mis_firmas")).filter( pk=orden_examen.id, can_firmas__gt=1, examen__especial=False, examen_estado=2, ) una_firma = OrdenExamenFirmas.objects.select_related( 'especialista', 'especialista__especialidad', 'orden_examen', 'orden_examen__examen', 'orden_examen__examen__subgrupo_cups', ).annotate(especialist=F('especialista'), can_firmas=Count("orden_examen__mis_firmas")).filter( orden_examen=orden_examen, orden_examen__examen__especial=False, can_firmas=1, orden_examen__examen_estado=2, ) ctx = { 'paciente': orden_examen.orden.paciente, 'orden': orden_examen.orden, 'entidad': orden_examen.orden.entidad, 'medico_remitente': orden_examen.orden.medico_remitente, 'multifirma': multifirma, 'una_firma': una_firma, 'examen': orden_examen, } html_get_template = get_template( 'email/ordenes/resultados/datos_orden.html').render(ctx) html = HTML(string=html_get_template, base_url=request.build_absolute_uri()) header_datos = html.render(stylesheets=[ CSS(string='div {position: fixed; top: 0, margin:0, padding:0}' ) ]) header_datos_page = header_datos.pages[0] header_datos_body = get_page_body( header_datos_page._page_box.all_children()) header_datos_body = header_datos_body.copy_with_children( header_datos_body.all_children()) html_get_template = get_template( 'email/ordenes/resultados/resultados.html').render(ctx) html = HTML(string=html_get_template, base_url=request.build_absolute_uri()) main_doc = html.render( stylesheets=[CSS('static/css/pdf_ordenes_resultado.min.css')]) for i, page in enumerate(main_doc.pages): page_body = get_page_body(page._page_box.all_children()) page_body.children += header_datos_body.all_children() output = BytesIO() main_doc.write_pdf(target=output) orden_examen.pdf_examen.delete() filename = "%s_ALE%s.pdf" % (orden_examen.nro_examen, random.randint(1000, 9999)) orden_examen.pdf_examen.save(filename, File(output)) output.close()
from utils import * import pandas as pd import numpy as np import pprint sched = get_schedule() extra_key = str(max([int(x) for x in sched.keys()])) del sched[extra_key] html_str = '' for i in sched: df = pd.DataFrame.from_dict(sched[i]).transpose() df.index.name = "Match-ID" df.columns = ['Player 1', 'Player 2'] html_str += "<h2>Day {}</h2>".format(i) + "\n" + df.to_html() + "\n\n" from jinja2 import Environment, FileSystemLoader env = Environment(loader=FileSystemLoader('.')) template = env.get_template("matches.html") template_vars = {"title": "Matchups", "national_pivot_table": html_str} html_out = template.render(template_vars) from weasyprint import HTML HTML(string=html_out).write_pdf("matchups.pdf", stylesheets=["style.css"])
def _create_pdf(rendered_template, absolute_url): from weasyprint import HTML pdf_file = HTML(string=rendered_template, base_url=absolute_url).write_pdf() return pdf_file
<meta charset="utf-8"> </head> <body> ''' for k in all_html: html += k + '<br>' + all_html[k] + '<hr>' html += "</body></html>" font_config = FontConfiguration() css = CSS(string=''' * { font-size : 0.8rem; } body { backgroud: black; } @font-face { font-family: Gentium; src: url(http://example.com/fonts/Gentium.otf); } h1 { font-family: Gentium } img {width: 30; height: 60}''', font_config=font_config) #print(html) report_html = HTML(string=html) report_html.write_pdf(target='test.pdf', stylesheets=[css], font_config=font_config)
def export_pdf(request): todays_date = datetime.date.today() year = todays_date.strftime("%d-%b-%Y").split("-")[2] month = todays_date.strftime("%d-%b-%Y").split("-")[1] year_list = { "Jan": 1, "Feb": 2, "Mar": 3, "Apr": 4, "May": 5, "Jun": 6, "Jul": 7, "Aug": 8, "Sep": 9, "Oct": 10, "Nov": 11, "Dec": 12 } month = year_list[month] allexpense = 0 date_start_month = datetime.date(int(year), month, 1) expenses = Expense.objects.filter(date__gte=date_start_month, date__lte=todays_date) if request.method == 'POST': data = request.body array1 = data.split(b'&') startAr = array1[0].decode("utf-8") endAr = array1[1].decode("utf-8") startAr = startAr.split('=') endAr = endAr.split('=') start = startAr[1] end = endAr[1] yearStart = start.split('-')[0] monthStart = start.split('-')[1] dayStart = start.split('-')[2] yearEnd = end.split('-')[0] monthEnd = end.split('-')[1] dayEnd = end.split('-')[2] start = datetime.date(int(yearStart), int(monthStart), int(dayStart)) end = datetime.date(int(yearEnd), int(monthEnd), int(dayEnd)) if end and start: expenses = Expense.objects.filter(date__gte=start, date__lte=end) response = HttpResponse(content_type='text/pdf') response['Content-Disposition'] = 'attachement; filename=BadolExpenses' + \ str(datetime.datetime.now()) + '.pdf' response['Content-Transfer-Encoding'] = 'binary' sum = expenses.aggregate(Sum('amount')) try: currency = UserPreference.objects.get(user=request.user).currency except: messages.success(request, 'Veuillez configurer votre monnaie') return redirect('preferences') allexpense = "{:.2f}".format(sum['amount__sum']) allexpense = str(allexpense) + currency html_string = render_to_string('expenses/pdf-output.html', { 'expenses': expenses, 'total': allexpense }) html = HTML(string=html_string) result = html.write_pdf() with tempfile.NamedTemporaryFile(delete=True) as output: output.write(result) output.flush() output = open(output.name, 'rb') response.write(output.read()) return response
def printreport(request, permit_request): """Return a PDF of the permit request generated using weasyprint. Parameters ---------- request : <class 'django.core.handlers.wsgi.WSGIRequest'> The user request. permit_request : <class 'permits.models.PermitRequest'> The permit request. Returns ------- pdf_permit : <class 'bytes'> The PDF of the permit request. """ geo_times = permit_request.geo_time.all() printurl = get_map_url(geo_times, permit_request.pk) print_date = timezone.now() validations = permit_request.validations.all() objects_infos = services.get_permit_objects(permit_request) actor_types = dict(models.ACTOR_TYPE_CHOICES) contacts = [(actor_types.get(contact['actor_type'].value(), ''), [ (field.label, field.value()) for field in contact if field.name not in {'id', 'actor_type'} ]) for contact in services.get_permitactorformset_initiated(permit_request) if contact['id'].value()] author = permit_request.author administrative_entity = permit_request.administrative_entity html = render( request, "permits/print/printpermit.html", { 'permit_request': permit_request, 'contacts': contacts, 'author': author, 'objects_infos': objects_infos, 'print_date': print_date, 'administrative_entity': administrative_entity, 'geo_times': geo_times, 'map_image': printurl, 'validations': validations, 'logo_main': b64encode( administrative_entity.logo_main.open().read()).decode("utf-8") if administrative_entity.logo_main else '', 'logo_secondary': b64encode(administrative_entity.logo_secondary.open().read( )).decode("utf-8") if administrative_entity.logo_secondary else '', 'image_signature_1': b64encode(administrative_entity.image_signature_1.open().read()). decode("utf-8") if administrative_entity.image_signature_1 else '', 'image_signature_2': b64encode(administrative_entity.image_signature_2.open().read()). decode("utf-8") if administrative_entity.image_signature_2 else '', }) pdf_permit = HTML( string=html.content, base_url=request.build_absolute_uri()).write_pdf( stylesheets=[CSS('/code/static/css/printpermit.css')]) file_name = 'permis_' + str(permit_request.pk) + '.pdf' permit_request.printed_file.save(file_name, ContentFile(pdf_permit), True) permit_request.printed_at = timezone.now() permit_request.printed_by = request.user.get_full_name() permit_request.save() return pdf_permit
import os from weasyprint import HTML from flask_frozen import Freezer from flask_weasyprint.test_app import app ROOT = os.path.dirname(os.path.abspath(__file__)) os.chdir(ROOT) app.config['FREEZER_DESTINATION'] = os.path.join(ROOT, 'frozen_demo') app.config['FREEZER_RELATIVE_URLS'] = True Freezer(app).freeze() HTML('http://www.pycon.fr/2012/schedule/').write_pdf( 'PyConFR_2012_schedule.pdf', stylesheets=['print.css'])
def quote(req, num=None, pdf=False): user = req.user quote_breadcrumb = Breadcrumb('Quotes', 'eRacks Quote List for %s' % user, '/quotes/') if 0: # messages_test from django.contrib import messages #messages.add_message(req, messages.INFO, 'Hello world.') #Some shortcut methods provide a standard way to add messages with commonly used tags (which are usually represented as HTML classes for the message): messages.debug(req, '%s SQL statements were executed.' % 123) messages.info(req, '%s SQL statements were executed.' % 123) messages.info(req, 'Three credits remain in your account.') messages.success(req, 'Profile details updated.') messages.warning(req, 'Your account expires in three days.') messages.error(req, 'Document deleted.') if num: # render it directly try: q = Quote.objects.get(quote_number=num) except Quote.DoesNotExist: raise Http404 if q: address1 = Address.objects.filter(customer=q.customer) #print address1 shipping_addr = None billing_addr = None if address1: for address in address1: print address.type if address.type == "shipping": shipping_addr = address if address.type == "billing": billing_addr = address if address.type == "both": shipping_addr = address billing_addr = address prod = dict( address1=address1, shipping_addr=shipping_addr, billing_addr=billing_addr, q=q, totprice=q.totprice, summary=q.summary, notes=q.header_items, # terms, discounts, etc? #qty = q.totqty, qty=1, opts={}, baseprice=q.totprice, weight=q.shipping, sku='Quote/%s' % q.quote_number, order_total=q.totprice + q.shipping) if req.POST.get('add', None): # add quote to cart as product prod = dict( totprice=q.totprice, summary=q.summary, notes=q.header_items, # terms, discounts, etc? #qty = q.totqty, qty=1, opts={}, baseprice=q.totprice, weight=q.shipping, sku='Quote/%s' % q.quote_number, order_total=q.totprice + q.shipping) ses = req.session ses['cart'] = ses.get('cart', []) + [prod] ses['prod'] = {} return HttpResponseRedirect('/cart/') text = "Your email confirmation, as PDF attachment\n\n" html_string = render_to_string('pdf/index.html', context=prod) html = HTML(string=html_string, base_url=req.build_absolute_uri()) pdf = html.write_pdf() #return HttpResponse (pdf, content_type='application/pdf') msg = EmailMultiAlternatives( 'Your %s eracks quote #%s' % (settings.HNN[0], q.quote_number), text, # nope: '', # let's try attaching the text, settings.ORDER_FROM_EMAIL, ['*****@*****.**']) msg.attach('eRacks_Quote_#%s.pdf' % q.quote_number, pdf, "application/pdf") # msg.send() if req.POST.get('pdf', None): # Render PDF file & return to user response = HttpResponse(content_type='application/pdf') response[ 'Content-Disposition'] = 'attachment; filename=eRacks_Quote_#%s.pdf' % q.quote_number response.write(pdf) return response # Drop thru: email admin, render the quote_number if not user.is_staff: subject = "%s user accessed %s" % (settings.HOST_NAME, req.path) ip = req.META.get( 'HTTP_X_FORWARDED_FOR', req.META.get('HTTP_X_REAL_IP', req.META.get('REMOTE_ADDR', 'unknown'))) message = quote_viewed_template.format(s=settings, ip=ip, u=user, r=req) to = settings.CONTACT_EMAILS fm = '*****@*****.**' # user.email send_mail(subject, message, fm, to, fail_silently=not settings.DEBUG) for line in q.quotelineitem_set.all( ): # lame: dj templates can't do multiplcation or expressions line.ext = line.quantity * line.price return render_to_response( 'quote.html', dict(title="Quote: %s" % q.quote_number, q=q, breadcrumbs=(quote_breadcrumb, Breadcrumb('Quote %s' % q.quote_number, 'Quote %s' % q.quote_number, '/quotes/%s' % q.quote_number))), context_instance=RequestContext(req)) else: # render the list if user.is_staff: qs = Quote.objects.filter(approved_by=user) else: qs = Quote.objects.filter(customer__user=user) return render_to_response('entries.html', dict( entries=qs, title='Quote list for %s' % user, breadcrumbs=(quote_breadcrumb, ), ), context_instance=RequestContext(req))
def post(self): data = json.loads(request.data) # drive variant drive = [data['product'], data['variant']] # default values and add offsets if not None HOR_F1200_MK = 422. + float( data['xshift'] if data['xshift'] != None else 0) VER_F1200_MK = 170. + float( data['yshift'] if data['yshift'] != None else 0) # basic components measure_rh_a = (float(data['width']) / 2) - 123. measure_rh_b = float(data['width']) - 307. measure_rv_a = (float(data['height']) / 2) - 225. measure_rv_b = float(data['height']) - 409. measure_rv_mk = VER_F1200_MK - 122. # optional component horizontal measure_rh_no_MV = HOR_F1200_MK - 175. # optional component horizontal and MV measure_rh_MV_a = HOR_F1200_MK - 225. measure_rh_MV_b = (float(data['width']) / 2) - 74. measures = [] # add basic rods measures = measures + [ measure_rh_a, measure_rh_b, measure_rv_a, measure_rv_b, measure_rv_mk ] # select optional rods if data['variant'] != "vertical" and int(data['height']) >= 1250: measures.append(measure_rh_MV_a) measures.append(measure_rh_MV_b) elif data['variant'] != "vertical": measures.append(measure_rh_no_MV) # render html file to python string render = render_template('pdf.html', measurements=measures, drive=drive) # define html to be converted to pdf html = HTML(string=render) # define path to css file for pdf styling css = CSS(filename='/app/app/templates/style.css') # generate pdf from html with css pdf = html.write_pdf(stylesheets=[css]) # build the http response to request response = make_response(pdf) response.headers['Content-Type'] = 'application/pdf' response.headers[ 'Content-Disposition'] = 'attachment;filename=output.pdf' return response
def html2pdf(html, outputfile, stylesheets=None): document = HTML(string=html) with open(outputfile, 'wb') as f: document.write_pdf(f, stylesheets=stylesheets)
import argparse parser = argparse.ArgumentParser(description='PDF maker with custom arguments') parser.add_argument("--title", default="", help="This is the title of the PDF") parser.add_argument("--subtitle", default="", help="This is the subtitle of the PDF") parser.add_argument("--text", default="", help="This is the text of the PDF") parser.add_argument("--outputpath", default="", help="This is the output path") args = parser.parse_args() title = args.title subtitle = args.subtitle text = args.text outputpath = args.outputpath if not outputpath: outputpath = 'pdfs/5_test_complicated_template_with_arguments.pdf' root = os.path.dirname(os.path.abspath(__file__)) htmlpath = os.path.join(root, 'templates', '5_test_complicated_template_with_arguments.html') with open(htmlpath, 'r') as file: html = file.read() html = html.replace("{% title %}", title) html = html.replace("{% subtitle %}", subtitle) html = html.replace("{% text %}", text) # now add the substitutions pdf_file = HTML(string=html).write_pdf(outputpath)
import markdown as md import codecs from weasyprint import HTML def htmlHead(str, styleTag=False): if styleTag: css_input = 'generic css style' outStr = '<html>\n\t<head>\n\t\t<style>' + css_input + '</style>\n\t</head>\n\t<body>' + str + '</body>\n<html>' else: outStr = '<html>\n\t<body>' + str + '</body>\n<html>' return outStr mdStr = htmlHead('test str here') fileName = "test.html" output_file = codecs.open(fileName, "w", encoding="utf-8", errors="xmlcharrefreplace") output_file.write(mdStr) HTML(fileName).write_pdf('test.pdf')
def download_file(self, html, file_name): response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename={}.pdf'.format( file_name) HTML(string=html).write_pdf(response) return response
def html_to_pdf(html: str, template_name: str): html = HTML(string=html) css = CSS(filename=get_css_location(template_name), font_config=font_config) return html.write_pdf(stylesheets=[css], font_config=font_config)
html = commonmark.commonmark(text) css = "" with open('./style.css', encoding='utf-8') as fr: css = fr.read() html_full = "<!DOCTYPE html>\n<html>\n<head>\n<style>\n" html_full += '@page { size: A4; margin: 1cm }\n' html_full += css if args.dc: with open('./style_doublecolumn.css', encoding='utf-8') as fr: css = fr.read() html_full += css html_full += "</style>\n</head>\n<body>\n" html_full += html html_full += "</body>\n</html>" html = HTML(string=html_full, encoding='utf-8') if args.output == None: out_file = os.path.splitext(args.input)[0] + '.pdf' html_file = os.path.splitext(args.input)[0] + '.html' else: out_file = os.path.splitext(args.output)[0] + '.pdf' html_file = os.path.splitext(args.output)[0] + '.html' if args.html: with open(html_file, "w", encoding='utf-8') as fw: fw.write(html_full) html.write_pdf(out_file)
def postpub(self): """ main publication function """ res = [] pivot = self.pivot body = pivot.xpath('/*/*[local-name() = "body"]')[0] head = pivot.xpath('/*/*[local-name() = "head"]')[0] # add css css = self.scriptdef.xpath('string(parameters/parameter[@name="CSS"]/@value)') logger.debug(css) baseurl = "file://%s"%(self.getOsPath("/")) csslink = "%s/kolekti/publication-templates/weasyprint/css/%s.css"%(baseurl,css) logger.debug(csslink) ET.SubElement(head,'link',attrib = { "rel":"stylesheet", "type":"text/css", "href": csslink }) ET.SubElement(head,'base',attrib = { "href": baseurl }) # make image urls relative in pivot for media in pivot.xpath("//h:img[@src]|//h:embed[@src]", namespaces=self.nsmap): src = media.get('src') if src[0] == "/": media.set('src', src[1:]) # produce pdf once pubdir = self.pubdir(self.assembly_dir, self.profile) pdf = os.path.join(self.getOsPath(pubdir),self.publication_file+'.pdf') HTML(string = ET.tostring(pivot)).write_pdf(pdf) if self.scriptdef.xpath('boolean(parameters/parameter[@name="two_passes"]/@value = "yes")'): # count pages in pdf with open(pdf, 'rb') as pdffile: nbpages = PdfFileReader(pdffile).getNumPages() logger.debug( "pdf nbpages : %d"%(nbpages,)) # update pivot body attributes body.set('data-pagecount', str(nbpages)) body.set('data-pagecount-mod-2', str(nbpages % 2)) body.set('data-pagecount-mod-4', str(nbpages % 4)) body.set('data-pagecount-mod-8', str(nbpages % 8)) body.set('data-pagecount-mod-16', str(nbpages % 16)) pivfile = pubdir + "/document_nbpage_attrs.xhtml" self.xwrite(pivot, pivfile, sync = False) # produce pdf with modified pivot HTML(string = ET.tostring(pivot)).write_pdf(pdf) subst = {} for p in self.scriptdef.xpath('parameters/parameter'): subst.update({p.get('name'):p.get('value')}) pubdir = self.pubdir(self.assembly_dir, self.profile) subst.update({ "APPDIR":self._appdir, "PLUGINDIR":self._plugindir, "PUBDIR":self.getOsPath(pubdir), "SRCDIR":self.getOsPath(self.assembly_dir), "BASEURI":self.getUrlPath(self.assembly_dir) + '/', "PUBURI":pubdir, "PUBNAME":self.publication_file, }) xl=self.scriptspec.find('link') outfile=self._substscript(xl.get('name'), subst, self.profile) outref=self._substscript(xl.get('ref'), subst, self.profile) outtype=xl.get('type') res=[{"type":outtype, "label":outfile, "url":outref, "file":outref}] return res
def export_report(request, pk): """ Export the reach back report to the user upon request Parameters ---------- request: rest_framework.request.Request The request object pk: int Flowcell primary key Returns ------- A PDF blob to be downloaded """ flowcell = Flowcell.objects.get(pk=pk) task = JobMaster.objects.filter(flowcell_id=pk, job_type_id=10).last() run = flowcell.runs.first() metagenomics_run = True if task else False alignment_data = PafSummaryCov.objects.filter( job_master__flowcell_id=pk).exclude( job_master__job_type__id=16).values() report_info = { "run_id": run.name, "read_count": run.summary.read_count, "yield": run.summary.total_read_length, "avg_read_length": run.summary.avg_read_length, "run_date": run.summary.first_read_start_time.strftime("%d/%m/%Y"), "run_duration": str(run.summary.last_read_start_time - run.summary.first_read_start_time), "alignment_data": bool(alignment_data), "metagenomics_data": metagenomics_run } if metagenomics_run: metadata = Metadata.objects.get(task=task) meta_dict = { "unclassified": metadata.unclassified, "classified": metadata.classified, "percent_classified": round(metadata.classified / run.summary.read_count * 100, 2), "percent_unclassified": round(metadata.unclassified / run.summary.read_count * 100, 2), } report_info.update(meta_dict) if alignment_data: alignment_dict = {"alignment_values": alignment_data} report_info.update(alignment_dict) print(request.data["basecalledSummaryHTML"]) print(request.data["liveEventSummaryHTML"]) report_info.update(request.data) cent_df = get_metagenomics_data(task, flowcell) cent_df.to_csv(f"/tmp/meta_csv_{run.name}.csv.gz", encoding="utf-8") HTML( string=render(request, "metagenomics/report.html", context={ "report_data": report_info }).getvalue() ).write_pdf( f"/tmp/{task.id}_run_{run.name}_report.pdf", stylesheets=[ CSS("web/static/web/css/report.css"), CSS("web/static/web/libraries/bootstrap-4.5.0-dist/css/bootstrap.css" ), ], ) tar_file_path = f"/tmp/{task.id}_run_{run.name}_report.tar.gz" tar_file_name = f"{task.id}_run_{run.name}_report.tar.gz" with tarfile.open(tar_file_path, "w:gz") as tar: try: tar.add(f"/tmp/{task.id}_run_{run.name}_report.pdf", recursive=False) tar.add(f"/tmp/meta_csv_{run.name}.csv.gz", recursive=False) except FileNotFoundError as e: print("file not found") with open(tar_file_path, "rb") as fh: response = HttpResponse(fh.read(), content_type="application/zip") response[ "Content-Disposition"] = f"attachment; filename={tar_file_name}" response["x-file-name"] = tar_file_name return response
def mk_report(self, start_time, end_time, profeat, path=None): """Produce PDF report. Args: start_time (int): start time UNIX timestamp. end_time (int): end time UNIX timestamp. profeat (dict): profile features. path (string): report file path (opt). Returns: None: writes PDF report. """ # From time to timestamp start_time = datetime.datetime.fromtimestamp(start_time) start_time = start_time.strftime('%Y-%m-%d %H:%M:%S') end_time = datetime.datetime.fromtimestamp(end_time) end_time = end_time.strftime('%Y-%m-%d %H:%M:%S') # Load template gpdir = pkg_resources.resource_filename(const.PACK_NAME, '') gpdir += '/static/' env = Environment(loader=FileSystemLoader(gpdir)) env.filters['type'] = type env.filters['has_key'] = lambda a, b: b in a.keys() template = env.get_template("report_template.html") # Prepare variables to fill the template tempv = { 'profeat': profeat, 'starttime': start_time, 'endtime': end_time, 'basedir': self.basedir, 'outdir': self.outdir, 'logpath': self.logpath, 'reg': self.reg, 'ext': self.ext, 'skip': [ const.STEP_DESCR[i - 1] for i in self.skip if i in range(len(const.STEP_DESCR)) ], 'ncores': self.ncores, #'correctca' : self.correctCA, 'verbose': self.verbose, 'debugging': self.debugging, 'suffix': self.suffix, 'dna_names': self.dna_names, 'sig_names': self.sig_names, 'plotting': self.plotting, 'fontsize': self.font_size, 'nbins': self.nbins, 'sigma_smooth': self.sigma_smooth, 'sigma_density': self.sigma_density, 'seg_type': const.SEG_LABELS[self.seg_type], 'adp_thr': self.adaptive_neighbourhood, 'radius_interval': self.radius_interval, 'min_z_size': self.min_z_size, 'offset': self.offset, 'rm_z_tips': self.do_clear_Z_borders, 'an_type': const.AN_LABELS[self.an_type], 'mid_type': const.MID_SEC_LABELS[self.mid_type], 'dist_type': self.dist_type, 'aspect': self.aspect, 'nsf': [ const.NSEL_NAMES[i] for i in self.nsf if i in range(len(const.NSEL_NAMES)) ], 'part_n_erosion': self.part_n_erosion, 'norm_d': self.normalize_distance, 'rescale_deconvolved': self.rescale_deconvolved, 'notes': self.notes, 'conds': self.conds, 'cnuclei': [sum([len(s.nuclei) for s in c.series]) for c in self.conds], 'cdescr': self.cdescr } # Escape characters for (k, v) in tempv.items(): if type('') == type(v): tempv[k] = v.replace('<', '<').replace('>', '>') # Fill template html_out = template.render(tempv) # Hide CSS warnings logger = logging.getLogger('weasyprint') logger.handlers = [] logger.addHandler(logging.FileHandler('/tmp/weasyprint.log')) # Output suffix = datetime.datetime.fromtimestamp(time.time()) suffix = suffix.strftime('%Y-%m-%d %H:%M:%S') fname = self.outdir + 'report.' + suffix + '.pdf' HTML(string=html_out).write_pdf(fname)