column = columns.index(name) row[column] = kw[name] def del_row(self, number): """Delete row at the given line number. Count begins at 0. """ self.set_changed() # Remove row = self.lines[number] if row is None: raise IndexError, 'list assignment index out of range' self.lines[number] = None def del_rows(self, numbers): """Delete rows at the given line numbers. Count begins at 0. """ self.set_changed() # Indexes are changing while deleting process for i in numbers: self.del_row(i) def get_unique_values(self, name): return set([ x.get_value(name) for x in self.get_rows() ]) register_handler_class(CSVFile)
output.append('</tmx>\n') return ''.join(output) ####################################################################### # API ####################################################################### def get_languages(self): languages = [] for m in self.messages.values(): for l in m.msgstr.keys(): if l not in languages: languages.append(l) return languages def get_srclang(self): return u'%s' % self.header['srclang'] def add_unit(self, filename, source, context, line): # XXX Context must be used!! # FIXME Use 'filename' and 'line' unit = TMXUnit({}) src_lang = self.header['srclang'] sentence = Sentence({'lang': src_lang}) sentence.text = source unit.msgstr[src_lang] = sentence self.messages[source] = unit return unit register_handler_class(TMXFile)
elif word in ('\\lquote', '\\rquote'): text.append("'") elif word in ('\\ldblquote', '\\rdblquote'): text.append('"') elif word in ('\\{', '\\}', '\\\\'): text.append(word[1]) text = ''.join(text) text = text.decode('quopri_codec') text = unicode(text, 'cp1252') return text ########################################################################### # Handler ########################################################################### class RTF(File): class_mimetypes = ['text/rtf'] class_extension = 'rtf' def to_text(self): return rtf_to_text(self.to_str()) # Register register_handler_class(RTF)
######################################################################### # Web Interface ######################################################################### def view(self): # Load the STL template handler = ro_database.get_handler('TaskTracker_view.xml') # Build the namespace namespace = {} namespace['tasks'] = [] for i, task in enumerate(self.tasks): namespace['tasks'].append({'id': i, 'title': task.title, 'description': task.description, 'state': task.state, 'is_open': task.state == 'open'}) # Process the template and return the output return stl(handler, namespace, mode='xhtml') register_handler_class(TaskTracker) if __name__ == '__main__': task_tracker = ro_database.get_handler('itools.tt') print task_tracker.view()
from itools.gettext import POFile from itools.handlers import register_handler_class, ro_database import itools.html import itools.python import itools.stl import itools.pdf from itools.pkg import get_config import itools.srx from itools.stl import STLFile from itools.uri import Path from itools.fs import lfs, WRITE # FIXME We register STLFile to override get_units of XHTMLFile handler # (See bug #864) register_handler_class(STLFile) def write(text): sys.stdout.write(text) sys.stdout.flush() if __name__ == '__main__': # The command line parser version = 'itools %s' % itools.__version__ description = ('Updates the message catalogs (POT and PO files) in the' ' "locale" directory, with the messages found in the' ' source.') parser = OptionParser('%prog', version=version, description=description)
def _load_state_from_file(self, file): # A new context context = { 'encoding': 'utf-8', 'current_ns': None, 'elements': [], 'references': {}, 'prefix': {} } context['prefix']['xml'] = xml_uri # Parse the file read_file(context, self.key, file) # And make the namespaces self.namespaces = make_namespaces(context) ######################################################################### # API Public ######################################################################### def auto_register(self): for uri, namespace in self.namespaces.iteritems(): if not has_namespace(uri): register_namespace(namespace) def get_namespaces(self): return self.namespaces register_handler_class(RelaxNGFile)
task.state = u'closed' ######################################################################### # Web Interface ######################################################################### def view(self): # Load the STL template handler = ro_database.get_handler('TaskTracker_view.xml') # Build the namespace namespace = {} namespace['tasks'] = [] for i, task in enumerate(self.tasks): namespace['tasks'].append({ 'id': i, 'title': task.title, 'description': task.description, 'state': task.state, 'is_open': task.state == 'open' }) # Process the template and return the output return stl(handler, namespace, mode='xhtml') register_handler_class(TaskTracker) if __name__ == '__main__': task_tracker = ro_database.get_handler('itools.tt') print task_tracker.view()
text.append(' ') elif word in ('\\emdash', '\\endash', '\\bullet', '\\_'): text.append('-') elif word in ('\\lquote', '\\rquote'): text.append("'") elif word in ('\\ldblquote', '\\rdblquote'): text.append('"') elif word in ('\\{', '\\}', '\\\\'): text.append(word[1]) text = ''.join(text) text = text.decode('quopri_codec') text = unicode(text, 'cp1252') return text ########################################################################### # Handler ########################################################################### class RTF(File): class_mimetypes = ['text/rtf'] class_extension = 'rtf' def to_text(self): return rtf_to_text(self.to_str()) # Register register_handler_class(RTF)
def __cmp__(self, other): if not isinstance(other, self.__class__): return 1 return cmp(self.events, other.events) def to_text(self): """Removes the markup and returns a plain text string. """ text = [ unicode(value, 'utf-8') for event, value, line in self.events if event == TEXT ] return u' '.join(text) ####################################################################### # API / Internationalization - Localization ####################################################################### def get_units(self, srx_handler=None): return get_units(self.events, srx_handler) def translate(self, catalog, srx_handler=None): stream = translate(self.events, catalog, srx_handler) return stream_to_str(stream) # Register register_handler_class(XMLFile)
from itools.core import add_type from itools.handlers import register_handler_class from odf import OOFile class SXWFile(OOFile): class_mimetypes = ['application/vnd.sun.xml.writer'] class_extension = 'sxw' class SXCFile(OOFile): class_mimetypes = ['application/vnd.sun.xml.calc'] class_extension = 'sxc' class SXIFile(OOFile): class_mimetypes = ['application/vnd.sun.xml.impress'] class_extension = 'sxi' # Register add_type('application/vnd.sun.xml.writer', '.sxw') add_type('application/vnd.sun.xml.calc', '.sxc') add_type('application/vnd.sun.xml.impress', '.sxi') for handler in [SXWFile, SXCFile, SXIFile]: register_handler_class(handler)
# (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # Import from itools from itools.handlers import register_handler_class, File try: from pdftotext import pdf_to_text except ImportError: pdf_to_text = None class PDFFile(File): class_mimetypes = ['application/pdf'] class_extension = 'pdf' def to_text(self): if pdf_to_text is None: return u"" return pdf_to_text(self.to_str()) register_handler_class(PDFFile)
####################################################################### # API ####################################################################### def get_languages(self): languages = [] for m in self.messages.values(): for l in m.msgstr.keys(): if l not in languages: languages.append(l) return languages def get_srclang(self): return u'%s' % self.header['srclang'] def add_unit(self, filename, source, context, line): # XXX Context must be used!! # FIXME Use 'filename' and 'line' unit = TMXUnit({}) src_lang = self.header['srclang'] sentence = Sentence({'lang': src_lang}) sentence.text = source unit.msgstr[src_lang] = sentence self.messages[source] = unit return unit register_handler_class(TMXFile)
continue data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) s.append(' </image>') # Append items for item in self.items: s.append(' <item>') # Required for name in rss_item_elements['required']: value = item[name] if value is None: continue data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) # Optional for name in rss_item_elements['optional']: value = item.get(name) if value is None: continue data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) s.append(' </item>') s.append(' </channel>') s.append('</rss>') return '\n'.join(s) register_handler_class(RSSFile)
def ppt_to_text(data): buffer = [] file = StringIO(data) ole = Ole(file) for entry in ole.readdir(): if entry.open() >= 0: if entry.name == 'PowerPoint Document': for text in do_ppt(entry): buffer.append(text) return u"".join(buffer) ########################################################################### # Handler ########################################################################### class MSPowerPoint(File): class_mimetypes = ['application/vnd.ms-powerpoint'] class_extension = 'ppt' def to_text(self): return ppt_to_text(self.to_str()) # Register register_handler_class(MSPowerPoint)
if func.id in ('MSG', 'INFO', 'ERROR'): text = node.args[0] if isinstance(text, Str): if type(text.s) is unicode and text.s.strip(): # Context = None msg = ((TEXT, text.s),), None, node.lineno self.messages.append(msg) class Python(TextFile): class_mimetypes = ['text/x-python'] class_extension = 'py' def get_units(self, srx_handler=None): data = self.to_str() # Make it work with Windows files (the parser expects '\n' ending # lines) data = ''.join([ x + '\n' for x in data.splitlines() ]) # Parse and Walk ast = parse(data) visitor = VisitorMSG() visitor.generic_visit(ast) return visitor.messages # Register register_handler_class(Python)
class VisitorUnicode(NodeVisitor): def __init__(self): self.messages = [] def visit_Str(self, str): if type(str.s) is unicode and str.s.strip(): # Context = None msg = ((TEXT, str.s), ), None, str.lineno self.messages.append(msg) class Python(TextFile): class_mimetypes = ['text/x-python'] class_extension = 'py' def get_units(self, srx_handler=None): data = self.to_str() # Make it work with Windows files (the parser expects '\n' ending # lines) data = ''.join([x + '\n' for x in data.splitlines()]) # Parse and Walk ast = parse(data) visitor = VisitorUnicode() visitor.generic_visit(ast) return visitor.messages # Register register_handler_class(Python)
data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) s.append(' </image>') # Append items for item in self.items: s.append(' <item>') # Required for name in rss_item_elements['required']: value = item[name] if value is None: continue data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) # Optional for name in rss_item_elements['optional']: value = item.get(name) if value is None: continue data = encode_element(name, value, encoding) s.append(' <%s>%s</%s>' % (name, data, name)) s.append(' </item>') s.append(' </channel>') s.append('</rss>') return '\n'.join(s) register_handler_class(RSSFile)
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # Import from itools from itools.handlers import register_handler_class, File try: from pdftotext import pdf_to_text except ImportError: pdf_to_text = None class PDFFile(File): class_mimetypes = ['application/pdf'] class_extension = 'pdf' def to_text(self): if pdf_to_text is None: return u"" return pdf_to_text(self.to_str()) register_handler_class(PDFFile)
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # Import from itools from itools.handlers import File, register_handler_class prefix = 'application/vnd.openxmlformats-officedocument.' class MSWordX(File): class_mimetypes = [prefix + 'wordprocessingml.document'] class_extension = 'docx' class MSExcelX(File): class_mimetypes = [prefix + 'spreadsheetml.sheet'] class_extension = 'xlsx' class MSPowerPointX(File): class_mimetypes = [prefix + 'presentationml.presentation'] class_extension = 'pptx' # Register register_handler_class(MSWordX) register_handler_class(MSExcelX) register_handler_class(MSPowerPointX)
# A new context context = {'encoding' : 'utf-8', 'current_ns' : None, 'elements': [], 'references': {}, 'prefix' : {}} # Parse the file read_file(context, self.key, file) # And make the namespaces self.namespaces = make_namespaces(context) ######################################################################### # API Public ######################################################################### def auto_register(self): for uri, namespace in self.namespaces.iteritems(): if not has_namespace(uri): register_namespace(namespace) def get_namespaces(self): return self.namespaces register_handler_class(RelaxNGFile)
def add_unit(self, filename, source, context, line): file = self.files.setdefault(filename, File(filename, {})) unit = XLFUnit({}) unit.source = source unit.context = context unit.line = line file.body[context, source] = unit return unit def gettext(self, source, context=None): """Returns the translation of the given message id. If the context /msgid is not present in the message catalog, then the message id is returned. """ key = (context, source) for file in self.files.values(): if key in file.body: unit = file.body[key] if unit.target: return unit.target return source register_handler_class(XLFFile)
######################################################################### def get_compiled_rules(self, language): result = [] for rule in self.get_rules(language): break_value, before_break, after_break = rule regexp = before_break or '.*?' if after_break: regexp += '(?=%s)' % after_break regexp = compile(regexp, DOTALL | MULTILINE) result.append((break_value, regexp)) return result def get_languages(self): return self.language_rules.keys() def get_rules(self, language): language_rules = self.language_rules cascade = self.header['cascade'] result = [] for pattern, lang in self.map_rules: if match(pattern, language, DOTALL | MULTILINE): if cascade: result.extend(language_rules[lang]) else: return language_rules[lang] return result register_handler_class(SRXFile)
# Optional 'description': String(default=''), 'keywords': Tokens, 'home-page': String(default=''), 'author': String(default=''), 'platform': String(default=''), 'supported-platform': String(default=''), 'classifiers': Tokens, 'requires': Tokens, 'provides': Tokens, 'obsoletes': Tokens, } register_handler_class(PKGINFOFile) def parse_setupconf(package_dir): """Return a dict containing information from setup.conf in a itools package plus the version of the package """ attributes = {} if not vfs.is_folder(package_dir): return attributes if not vfs.exists(join(package_dir, "setup.conf")): return attributes config = SetupFile(join(package_dir, "setup.conf")) for attribute in config.schema: attributes[attribute] = config.get_value(attribute) if vfs.exists(join(package_dir, "version.txt")):
else: value = Property(value) # Case 4: Simple cls = self.database.get_resource_class(self.format) field = cls.get_field(name) if field is None or field.multiple is False: properties[name] = value return # Case 5: Multiple (append) if not field.datatype.is_empty(value.value): properties.setdefault(name, []).append(value) def set_property(self, name, value): self.set_changed() self._set_property(name, value) def del_property(self, name): if name in self.properties: self.set_changed() del self.properties[name] ########################################################################### # Register ########################################################################### register_handler_class(Metadata) for mimetype in Metadata.class_mimetypes: add_type(mimetype, '.%s' % Metadata.class_extension)
class ODTFile(ODFFile): class_mimetypes = ['application/vnd.oasis.opendocument.text'] class_extension = 'odt' namespace = 'urn:oasis:names:tc:opendocument:xmlns:text:1.0' class ODSFile(ODFFile): class_mimetypes = ['application/vnd.oasis.opendocument.spreadsheet'] class_extension = 'ods' namespace = 'urn:oasis:names:tc:opendocument:xmlns:spreadsheet:1.0' class ODPFile(ODFFile): class_mimetypes = ['application/vnd.oasis.opendocument.presentation'] class_extension = 'odp' namespace = 'urn:oasis:names:tc:opendocument:xmlns:presentation:1.0' # Register handler and mimetypes for handler in [ODTFile, ODSFile, ODPFile]: add_type(handler.class_mimetypes[0], '.%s' % handler.class_extension) register_handler_class(handler)
# Case 4: Simple cls = self.database.get_resource_class(self.format) field = cls.get_field(name) if field is None or field.multiple is False: properties[name] = value return # Case 5: Multiple (append) if not field.datatype.is_empty(value.value): properties.setdefault(name, []).append(value) def set_property(self, name, value): self.set_changed() self._set_property(name, value) def del_property(self, name): if name in self.properties: self.set_changed() del self.properties[name] ########################################################################### # Register ########################################################################### register_handler_class(Metadata) for mimetype in Metadata.class_mimetypes: add_type(mimetype, '.%s' % Metadata.class_extension)
def gettext(self, source, context=None): """Returns the translation of the given message id. If the context /msgid is not present in the message catalog, or if it is marked as "fuzzy", then the message id is returned. """ message = self.messages.get((context, encode_source(source))) if message and not message.fuzzy: target = ''.join(message.target) if target: return decode_target(target) return source def add_unit(self, filename, source, context, line): if not source: return None # Change self.set_changed() source = encode_source(source) return self._set_message(context, [source], [u''], [], (filename, line)) register_handler_class(POFile)
break_value, before_break, after_break = rule regexp = before_break or '.*?' if after_break: regexp += '(?=%s)' % after_break regexp = compile(regexp, DOTALL | MULTILINE) result.append((break_value, regexp)) return result def get_languages(self): return self.language_rules.keys() def get_rules(self, language): language_rules = self.language_rules cascade = self.header['cascade'] result = [] for pattern, lang in self.map_rules: if match(pattern, language, DOTALL | MULTILINE): if cascade: result.extend(language_rules[lang]) else: return language_rules[lang] return result register_handler_class(SRXFile)
def to_str(self, encoding='UTF-8'): return stream_to_str(self.events, encoding) def set_events(self, events): self.set_changed() self.events = events def __cmp__(self, other): if not isinstance(other, self.__class__): return 1 return cmp(self.events, other.events) def to_text(self): """Removes the markup and returns a plain text string. """ return xml_to_text(self.events) ####################################################################### # API / Internationalization - Localization ####################################################################### def get_units(self, srx_handler=None): return get_units(self.events, srx_handler) def translate(self, catalog, srx_handler=None): stream = translate(self.events, catalog, srx_handler) return stream_to_str(stream) # Register register_handler_class(XMLFile)
'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"\n' ' "http://www.w3.org/TR/html4/loose.dtd">\n' '<html>\n' ' <head>\n' ' <meta http-equiv="Content-Type" content="text/html;' 'charset=UTF-8">\n' ' <title>%(title)s</title>\n' ' </head>\n' ' <body></body>\n' '</html>') return skeleton % {'title': title} def _load_state_from_file(self, file): data = file.read() stream = HTMLParser(data) self.events = list(stream) def load_state_from_string(self, string): self.reset() stream = HTMLParser(string) self.events = list(stream) to_str = XHTMLFile.to_html def translate(self, catalog, srx_handler=None): stream = translate(self.events, catalog, srx_handler) return stream_to_str_as_html(stream) register_handler_class(HTMLFile)
from itools.database.ro import ro_database import itools.html import itools.python import itools.stl import itools.pdf from itools.stl import STLFile from itools.uri import Path from itools.fs import lfs, WRITE # Import from here from utils import get_config # FIXME We register STLFile to override get_units of XHTMLFile handler # (See bug #864) register_handler_class(STLFile) def write(text): sys.stdout.write(text) sys.stdout.flush() def update_locale(srx_handler, exclude_folders, no_wrap=False): # Read configuration for languages config = get_config() src_language = config.get_value('source_language', default='en') # Get local folder package_root = config.get_value('package_root') if lfs.exists(package_root):
return ((files_id, sources, targets)) def add_unit(self, filename, source, context, line): file = self.files.setdefault(filename, File(filename, {})) unit = XLFUnit({}) unit.source = source unit.context = context unit.line = line file.body[context, source] = unit return unit def gettext(self, source, context=None): """Returns the translation of the given message id. If the context /msgid is not present in the message catalog, then the message id is returned. """ key = (context, source) for file in self.files.values(): if key in file.body: unit = file.body[key] if unit.target: return unit.target return source register_handler_class(XLFFile)
# Import from itools from itools.handlers import File, register_handler_class prefix = 'application/vnd.openxmlformats-officedocument.' class MSWordX(File): class_mimetypes = [prefix + 'wordprocessingml.document'] class_extension = 'docx' class MSExcelX(File): class_mimetypes = [prefix + 'spreadsheetml.sheet'] class_extension = 'xlsx' class MSPowerPointX(File): class_mimetypes = [prefix + 'presentationml.presentation'] class_extension = 'pptx' # Register register_handler_class(MSWordX) register_handler_class(MSExcelX) register_handler_class(MSPowerPointX)
self._set_message(context, [source], [target]) def gettext(self, source, context=None): """Returns the translation of the given message id. If the context /msgid is not present in the message catalog, or if it is marked as "fuzzy", then the message id is returned. """ message = self.messages.get((context, encode_source(source))) if message and not message.fuzzy: target = ''.join(message.target) if target: return decode_target(target) return source def add_unit(self, filename, source, context, line): if not source: return None # Change self.set_changed() source = encode_source(source) return self._set_message(context, [source], [u''], [], [(filename, line)]) register_handler_class(POFile)
'charset=UTF-8">\n' ' <title>%(title)s</title>\n' ' </head>\n' ' <body></body>\n' '</html>') return skeleton % {'title': title} def _load_state_from_file(self, file): data = file.read() stream = HTMLParser(data) self.events = list(stream) def load_state_from_string(self, string): self.set_changed() self.reset() stream = HTMLParser(string) self.events = list(stream) to_str = XHTMLFile.to_html def translate(self, catalog, srx_handler=None): stream = translate(self.events, catalog, srx_handler) return stream_to_str_as_html(stream) register_handler_class(HTMLFile)
yield char def ppt_to_text(data): buffer = [] file = StringIO(data) ole = Ole(file) for entry in ole.readdir(): if entry.open() >= 0: if entry.name == 'PowerPoint Document': for text in do_ppt(entry): buffer.append(text) return u"".join(buffer) ########################################################################### # Handler ########################################################################### class MSPowerPoint(File): class_mimetypes = ['application/vnd.ms-powerpoint'] class_extension = 'ppt' def to_text(self): return ppt_to_text(self.to_str()) # Register register_handler_class(MSPowerPoint)
def to_text(self): if open_workbook is None: return u"" data = self.to_str() # Load the XLRD file # XXX This is slow (try 'print book.load_time_stage_2') book = open_workbook(file_contents=data) # Get the text text = [] for sheet in book.sheets(): for idx in range(sheet.nrows): for value in sheet.row_values(idx): if type(value) is not unicode: try: value = unicode(value) except UnicodeError: continue text.append(value) return u' '.join(text) # Register register_handler_class(MSWord) register_handler_class(MSExcel)
if __name__ == '__main__': # Open a log file for failed files if not exists('error_logs'): make_file('error_logs') errors = open('error_logs', 'rw') # does 'a' flag works ?? errors.write(errors.read()) errors.write("# -- Error log --\n") errors.write("# Please update those file manually\n") # Register ConfigFile to .conf ConfigFile.class_mimetypes = ['text/x-setup_conf'] add_type('text/x-setup_conf', '.conf') register_handler_class(ConfigFile) db = Database().get_handler('documents') count = 0 # For each test case for f in db.traverse(): if str(f.uri).endswith('setup.conf'): # Has to update it url = str(f.uri) splited = url.split('/') i = 0 for split in splited: if split == 'documents': i += 1 break i += 1