| |
| from __future__ import absolute_import, division, print_function, unicode_literals |
| from future.utils import raise_from, string_types |
| from builtins import (bytes, str, open, super, range, |
| zip, round, input, int, pow, object) |
|
|
| import os |
| import types |
| import argparse |
| import traceback |
| from gslab_make.private.exceptionclasses import CritError |
|
|
| try: |
| from html.parser import HTMLParser |
| except: |
| from HTMLParser import HTMLParser |
|
|
| import gslab_make.textfill_info as textfill_info |
|
|
| def textfill(**kwargs): |
| try: |
| args = parse_arguments(kwargs) |
| text = parse_text(args) |
| insert_text(args, text) |
| exitmessage = args['template'] + ' filled successfully by textfill' |
| print(exitmessage) |
| return exitmessage |
| |
| except: |
| print('Error Found') |
| exitmessage = traceback.format_exc() |
| print(exitmessage) |
| return exitmessage |
|
|
| |
| textfill.__doc__ = textfill_info.__doc__ |
| |
|
|
| def parse_arguments(kwargs): |
| args = dict() |
| if 'input' in kwargs.keys(): |
| input_list = kwargs['input'].split() |
| args['input'] = input_list |
| if 'template' in kwargs.keys(): |
| args['template'] = kwargs['template'] |
| if 'output' in kwargs.keys(): |
| args['output'] = kwargs['output'] |
| if 'remove_echoes' in kwargs.keys(): |
| args['remove_echoes'] = kwargs['remove_echoes'] |
| else: |
| args['remove_echoes'] = False |
| if 'size' in kwargs.keys(): |
| args['size'] = kwargs['size'] |
| else: |
| args['size'] = 'Default' |
| if 'prefix' in kwargs.keys(): |
| args['prefix'] = kwargs['prefix'] + "_" |
| else: |
| args['prefix'] = 'textfill_' |
| |
| return args |
|
|
|
|
| def parse_text(args): |
| text = read_text(args['input'], args['prefix']) |
| text = clean_text(text, args['remove_echoes']) |
| |
| return text |
|
|
|
|
| def read_text(input, prefix): |
| data = '' |
| if isinstance(input, types.StringTypes): |
| input = [input] |
| for file in input: |
| data += open(file, 'rU').read() |
| text = text_parser(prefix) |
| text.feed(data) |
| text.close() |
| |
| return text |
|
|
|
|
| class text_parser(HTMLParser): |
| def __init__(self, prefix): |
| HTMLParser.__init__(self) |
| self.recording = False |
| self.results = {} |
| self.open = [] |
| self.closed = [] |
| self.prefix = prefix |
| |
| def handle_starttag(self, tag, attrs): |
| if tag.startswith(self.prefix): |
| tag_name = tag.replace(self.prefix, '', 1) |
| self.recording = True |
| self.results[tag_name] = '' |
| self.open.append(tag_name) |
| |
| def handle_data(self, data): |
| if self.recording: |
| self.results[self.open[-1]]+=data |
| |
| def handle_endtag(self, tag): |
| if tag.startswith(self.prefix): |
| tag_name = tag.replace(self.prefix, '', 1) |
| self.open.remove(tag_name) |
| self.closed.append(tag_name) |
| if not self.open: |
| self.recording = False |
| |
| def close(self): |
| for tag in self.results.keys(): |
| if tag not in self.closed: |
| raise CritError('Tag %s is not closed' % tag) |
|
|
|
|
| def clean_text(text, remove_echoes): |
| for key in text.results: |
| data = text.results[key].split('\n') |
| if remove_echoes: |
| data = filter(lambda x: not x.startswith('.'), data) |
| else: |
| data = filter(lambda x: not x.startswith('. insert_tag'), data) |
| data = remove_trailing_leading_blanklines(data) |
| text.results[key] = '\n'.join(data) |
| |
| return text |
|
|
|
|
| def remove_trailing_leading_blanklines(list): |
| while list and not list[0]: |
| del list[0] |
| while list and not list[-1]: |
| del list[-1] |
| |
| return list |
|
|
|
|
| def insert_text(args,text): |
| lyx_text = open(args['template'], 'rU').readlines() |
| |
| n = 0 |
| loop = True |
| while loop==True: |
| n+=1 |
| if n<len(lyx_text): |
| if (lyx_text[n].startswith('name "text:')): |
| tag = lyx_text[n].replace('name "text:','',1).rstrip('"\n').lower() |
| if tag in text.results: |
| |
| insert_now = False |
| i = n |
| while insert_now is False: |
| i+=1 |
| if lyx_text[i]=='\\end_layout\n': |
| insert_now = True |
| |
| |
| for key in text.results: |
| if tag==key: |
| lyx_code = write_data_to_lyx(text.results[key], args['size']) |
| lyx_text.insert(i+1, lyx_code) |
| else: |
| loop = False |
| |
| outfile = open(args['output'], 'wb') |
| outfile.write( ''.join(lyx_text) ) |
| outfile.close() |
| |
| return lyx_text |
|
|
|
|
| def write_data_to_lyx(data, size): |
| data_list = data.split('\n') |
| linewrap_beg = '\\begin_layout Plain Layout\n' |
| linewrap_end = '\\end_layout\n' |
| if size!='Default': |
| size_line = '\\backslash\n' + size + '\n' + linewrap_end + linewrap_beg |
| else: |
| size_line = '' |
| |
| preamble = '\\begin_layout Plain Layout\n' \ |
| '\\begin_inset ERT status collapsed\n' \ |
| '\\begin_layout Plain Layout\n' + size_line + \ |
| '\\backslash\nbegin{verbatim}\n' \ |
| '\end_layout' |
| postamble = '\\begin_layout Plain Layout\n' \ |
| '\\backslash\nend{verbatim}\n' \ |
| '\end_layout\n' \ |
| '\end_inset\n' \ |
| '\end_layout' |
| |
| lyx_code = preamble |
| for line in data_list: |
| lyx_code += linewrap_beg + line + linewrap_end |
| lyx_code += postamble |
| |
| return lyx_code |
|
|
