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)
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)
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)
# 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")):
'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
