Пример #1
0
def compile_pdf(error, output):
    # Load document-template
    try:
        f = codecs.open(path.join(path_constants.installation, FATAL_ERROR_TEX_FILE), encoding='utf-8')
    except:
        raise IOError("Problem loading document template.")
    
    tex_code = u''
    for line in f: tex_code += line
    
    tex_code = tex_code % error
    
    try:
        pdf = latex2pdf(unicode(tex_code))
    except Exception as exc:
        raise RuntimeError("Problem generating pdf: %s" % exc)
    
    try:
        f = open(output, 'wb+')
    except Exception as exc:
        raise IOError("Problem opening file for output: %s" % exc)
        
    try:
        f.write(pdf)
        f.close()
    except Exception as exc:
        f.close()
        raise RuntimeError("Problem writing to PDF file: %s" % exc)
Пример #2
0
def generate(name, oformat):
    tformat = oformat
    if oformat == 'pdf':
        tformat = 'latex'
    conn = sqlite3.connect( DBFILE )
    db = conn.cursor()
    presentation = db.execute('SELECT title,author,text FROM presentations WHERE name=?', (name,) ).fetchone()
    p_title = presentation[0]
    p_author = presentation[1]
    p_text = presentation[2]
    rows = db.execute('SELECT slide,title,text FROM slides WHERE name=?', (name,) ).fetchall()
    new_rows = []
    for row in rows:
        new_row = (row[0], row[1], pypandoc.convert(row[2], tformat, format='markdown'))
        new_rows.append(new_row)
    rows = new_rows
    tpl = 'slides.' + oformat
    result = template(tpl, name=name, rows=rows, p_title=p_title, p_author=p_author)
    if oformat == 'html':
        return result
    elif oformat == 'pdf':
        result = latex2pdf(result)
        response.content_type = 'application/pdf'
        return result
    elif oformat == 'latex':
        response.content_type = 'text/plain; charset=utf-8'
        return result
Пример #3
0
def download():
    if flask.request.method != 'POST':
        return flask.redirect(flask.url_for('index'))

    number = flask.request.form['number']
    if not number.isdigit():
        return flask.render_template('error.html',
                                     msg=u'Задано некорректное число задач.')
    else:
        number = int(number)
        if number <= 0:
            return flask.render_template('error.html',
                                         msg=u'Задано слишком маленькое число задач.')
        if number > 200:
            return flask.render_template('error.html',
                                         msg=u'Задано слишком большое число задач.')

    docType = flask.request.form['type']
    if not docType in ['x-tex','pdf']:
        return flask.render_template('error.html',
                                     msg=u'Задан неверный тип документа.')

    data = markov.generate_tex(number)
    if docType == 'pdf':
        data = tex.latex2pdf(data.decode('utf8'))
    response = flask.make_response(data)
    response.headers['Content-Type'] = 'application/%s' % docType
    response.headers['Content-Disposition'] = 'attachment; filename="tasks"'
    return response
Пример #4
0
 def test_instructionToLatex_renders(self):
     # Verify all instructions render correctly:
     ents = []
     for i in cue.Instruction.__dict__:
         if '__' in i:
             continue
         instruction = cue.Instruction.__dict__[i]
         ents.append(cue.Entry(instruction, r"Description", 0.0))
     r = cue.Route(ents, route_id=123, length_mi=0.0)
     latex_code = latex.makeLatex(r)
     pdf_data = tex.latex2pdf(latex_code)
Пример #5
0
def get_pdf(tex_obj):
    "creates a pdf from a textab object (using tex)"
    txt = tex_obj.get_tex()
    document = u"""
\\documentclass{article}
\\usepackage{booktabs}
\\begin{document}
%s
\\end{document}
""" % txt
    pdf = tex.latex2pdf(document)
    return pdf
Пример #6
0
	def gen_doc(self, status):
 		try:
		 	l = self.produce_list()

			self.document = self.document % tuple(l + [status])
			self.document = self.document.replace("pct.", "\%")
	
			pdf = latex2pdf(unicode(self.document))
			
			f = open(self.the_file, 'wb+')
		
			f.write(pdf)
		
			f.close()
			
 		except Exception as exc:
 			raise RuntimeError("Problem compiling document: %s" % exc)
Пример #7
0
def _QuickRender(instruction=cue.Instruction.NONE,
                 modifier=cue.Modifier.NONE,
                 description="",
                 note="",
                 abs_dist=0.0,
                 for_dist=0.0,
                 color=cue.Color.NONE):
    '''
  Renders a single instruction to PDF.
  '''
    ent = [
        cue.Entry(instruction, description, abs_dist, note, modifier, for_dist,
                  color)
    ]
    r = cue.Route(ent, route_id=123, length_mi=0.0)
    latex_code = latex.makeLatex(r)
    pdf = tex.latex2pdf(latex_code)
Пример #8
0
 def test_latexRenderTest(self):
     '''
 Create a few very pathological cue entries, verify the latex rendering
 doesn't choke:
 '''
     ents = [
         cue.Entry(cue.Instruction.LEFT,
                   r"Are we escaping everything # & $ | < > % \\ {} ???",
                   0.0),
         cue.Entry(
             cue.Instruction.LEFT,
             r"What **about *formatting***? **Does **it** work, too?**",
             0.1)
     ]
     r = cue.Route(ents,
                   route_id=123,
                   route_name=r"\terrible &oute Name \\ %%%",
                   elevation_gain_ft=123.45,
                   length_mi=123.456)
     latex_code = latex.makeLatex(r)
     pdf_data = tex.latex2pdf(latex_code)
Пример #9
0
    def run(self):
        """
        Actual fetcher. Could this be threaded?
        """
        url = view_text_json % self.url
        logger.debug("Fetching URL: " + url)
        raw_content = urllib2.urlopen(url)
        json_content = json.loads(raw_content.read())
        test_content = json_content['content']
        test_content = unicodedata.normalize('NFKD',
                test_content).encode('ascii', 'ignore')

        # Here, we begin constructing the syntax tree
        parser = MyHTMLParser()
        parser.feed(test_content)

        string = """
\\documentclass[12pt]{article}
\\begin{document}
{\\Large %s}
            """ % clean(json_content['title'])

        for line in parser.lines:
            line = escape_latex(line)
            string += line
        
        string += """
\\end{document}
        """

        with open('temp.latex', 'wb+') as f:
            f.write(string)

        pdf = latex2pdf(string)
        with open('temp.pdf', 'wb+') as f:
            f.write(pdf)
code = "".join(map(lambda x: str(x), source))
print code



# In[ ]:

book = {"parts": [
       #alice_in_curiosity_country,
        gettysburg_address
]}
latex = build_latex(book)
f = open("book4.tex","w")
f.write(latex)
f.close()


# In[ ]:

from tex import latex2pdf 
pdf = latex2pdf(latex) 
f = open("book.pdf", 'w+')
f.write(pdf)
f.close()


# In[ ]:



Пример #11
0
from tex import latex2pdf
document = ur"""
... \documentclass{article}
... \begin{document}
... Hello, World!
... \end{document}
... """

print 'got here'
pdf = latex2pdf(document)
type(pdf)
<type 'str'>
print "PDF size: %.1f KB" % (len(pdf) / 1024.0)
PDF size: 5.6 KB
pdf[:5]
'%PDF-'
pdf[-6:]
'%%EOF\n'
Пример #12
0
from tex import latex2pdf
import sys

if __name__ == "__main__":
    sys.stdout.write(latex2pdf(sys.stdin.read().decode("utf-8")))
    
Пример #13
0
#!/usr/bin/env python2
Пример #14
0
if not route_id.isalnum():
  htmlError("Invalid route id: " + cgi.escape(route_id))
  sys.exit(1)

md5_hash = None
cue_entries = None
try:
  md5_hash, cue_entries = ridewithgps.getMd5AndCueSheet(route_id)
except ridewithgps.RideWithGpsError as e:
  htmlError("Error querying RideWithGPS: %s" % e)
  sys.exit(1)

basefilename = "%s-%s" % (route_id, md5_hash)
pdffilename  = basefilename + ".pdf"

# base_dir = "/mnt/shared/mucow_cgi/roboviva/"
base_dir = '.'
os.chdir(base_dir)

# Check if we've done this already:
if not dataExists(pdffilename, base_dir):
  latex = latex.makeLatex(cue_entries)
  try:
    with open(pdffilename, 'wb') as pdffile:
      pdffile.write(tex.latex2pdf(latex))
  except:
    htmlError("Error formatting latex!\n\n" + latex) 
    sys.exit(1)

servePDF(pdffilename)