rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
except IOError, e: stdout = '' stderr = str(e) else: stderr = open(stderr_path).read() | except IOError: vfs.remove(path) raise stderr = open(stderr_path).read() | def convert(handler, cmdline, outfile=None): cmdline = cmdline % 'stdin' # Serialize the handler to a temporary file in the file system path = tempfile.mkdtemp('itools') file_path = path_join(path, 'stdin') open(file_path, 'w').write(handler.to_str()) # stdout & stderr stdout_path = path_join(path, 'stdout') stdout =... |
stdout, stderr = convert(self, self.source_converter, outfile) | try: stdout, stderr = convert(self, self.source_converter, outfile) except (OSError, IOError): context = get_context() context.server.log_error(context) return u'' | def to_text(self, outfile=None): stdout, stderr = convert(self, self.source_converter, outfile) |
context.server.log_error() | context.server.log_error(context) | def to_text(self, outfile=None): stdout, stderr = convert(self, self.source_converter, outfile) |
source_converter = 'wvText "%s" out.txt' | source_converter = 'wvText %s out.txt' | def to_text(self, outfile=None): stdout, stderr = convert(self, self.source_converter, outfile) |
source_converter = 'xlhtml -a -fw -nc -nh -te "%s"' | source_converter = 'xlhtml -a -fw -nc -nh -te %s' | def to_text(self): return OfficeDocument.to_text(self, 'out.txt') |
stdout, stderr = convert(self, self.source_converter) | try: stdout, stderr = convert(self, self.source_converter) except (OSError, IOError): context = get_context() context.server.log_error(context) return u'' | def to_text(self): stdout, stderr = convert(self, self.source_converter) |
source_converter = 'ppthtml "%s"' | source_converter = 'ppthtml %s' | def to_text(self): stdout, stderr = convert(self, self.source_converter) |
source_converter = 'pdftotext -enc UTF-8 -nopgbrk "%s" -' | source_converter = 'pdftotext -enc UTF-8 -nopgbrk %s -' | def to_text(self): file = StringIO(self.to_str()) try: zip = ZipFile(file) content = zip.read('content.xml') zip.close() text = xml_to_text(content) except BadZipfile: context = get_context() context.server.log_error(context) text = u'' |
value = None, 'a', {} | value = None, 'a', {}, {} | def test_element(self): data = '<a>' token = START_ELEMENT value = None, 'a', {} self.assertEqual(Parser(data).next(), (token, value, 1)) |
value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'} | value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'}, {} | def test_attributes(self): data = '<a href="http://www.ikaaro.org">' token = START_ELEMENT value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'} self.assertEqual(Parser(data).next(), (token, value, 1)) |
value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'} | value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'}, {} | def test_attributes_single_quote(self): data = "<a href='http://www.ikaaro.org'>" token = START_ELEMENT value = None, 'a', {(None, 'href'): 'http://www.ikaaro.org'} self.assertEqual(Parser(data).next(), (token, value, 1)) |
value = None, 'img', {(None, 'title'): 'Black & White'} | value = None, 'img', {(None, 'title'): 'Black & White'}, {} | def test_attributes_entity_reference(self): data = '<img title="Black & White">' token = START_ELEMENT value = None, 'img', {(None, 'title'): 'Black & White'} self.assertEqual(Parser(data).next(), (token, value, 1)) |
description = """Itools is a Python package that encapsulates several Python tools developed by the Itaapy company and other developers. The provided tools are: | description = """itools is a Python library, it groups a number of packages into a single meta-package for easier development and deployment. The packages included are: | def finalize_options (self): self.set_undefined_options('install', ('install_purelib', 'install_dir'), ('root', 'root'), ('force', 'force'), ) |
* itools.uri -- an API to manage URIs, to identify and locate resources. * itools.schema -- several type marshalers for basic types (integer, date, etc.) and not so basic types (filenames, XML qualified names, etc.) * itools.resources -- an abstraction layer over resources that let to manage them with a consistent AP... | - itools.catalog - itools.datatypes - itools.gettext - itools.handlers - itools.html - itools.i18n - itools.ical - itools.resources - itools.rss - itools.schemas - itools.tmx - itools.uri - itools.web - itools.workflow - itools.xhtml - itools.xliff - itools.xml | def finalize_options (self): self.set_undefined_options('install', ('install_purelib', 'install_dir'), ('root', 'root'), ('force', 'force'), ) |
cookie_raw = 'Set-Cookie: %s="%s"%s\n' % (name, cookie.value, ''.join(parameters)) data.append(cookie_raw) | prefix, local_name = QName.decode(name) datatype = get_datatype_by_prefix(prefix, local_name) value = datatype.encode(cookie.value) data.append( 'Set-Cookie: %s="%s"%s\n' % (name, value, ''.join(parameters))) | def to_str(self): state = self.state |
element.parent = self | def set_element(self, element): # XXX Use weak references? element.parent = self self.children.append(element) | |
handler.parent = self | handler.parent = container | def set_handler(self, path, handler, **kw): if not isinstance(path, uri.Path): path = uri.Path(path) |
self.timestamp = datetime.now() | container.timestamp = datetime.now() | def set_handler(self, path, handler, **kw): if not isinstance(path, uri.Path): path = uri.Path(path) |
handler_class = self.get_handler_class(class_id) | def new_resource(self, class_id, name, **kw): context = get_context() request = context.request | |
name = FileName.encode((name, handler.class_extension, kw.get('dc:language'))) | def new_resource(self, class_id, name, **kw): context = get_context() request = context.request | |
s.append(child) | s.append(child.encode(encoding)) | def to_str(self, encoding='UTF-8'): s = [] # The declaration if self.state.document_type is not None: s.append('<!%s>' % self.state.document_type) # The children for child in self.state.children: if isinstance(child, unicode): s.append(child) else: s.append(child.to_str(encoding)) return ''.join(s) |
version = "0.4.0", | version = "0.4.1", | def build_module(self, module, module_file, package): if isinstance(package, str): package = package.split('.') elif not isinstance(package, (list, tuple)): raise TypeError, \ "'package' must be a string (dot-separated), list, or tuple" |
Object.before_commit(self) | Handler.before_commit(self) | def before_commit(self): Object.before_commit(self) self.commit_revision() |
line = [ '%s' % x for x in line ] | line = [ '"%s"' % x for x in line ] | def to_unicode(self): s = u'' for line in self.lines: line = [ '%s' % x for x in line ] s += ','.join(line) + '\n' return s |
for d in range(ndays): ns_day = {} params = '%sdate=%s&timetable=%s'\ % (base_param, Date.encode(day), index) ns_day['url'] = '%s%s' % (base_url, params) ns_day['events'] = self.get_events(day, method, timetable, resource_name=resource_name, show_conflicts=show_conflicts) ns_days.append(ns_day) | for d in range(7): if d < ndays: ns_day = {} params = '%sdate=%s&timetable=%s'\ % (base_param, Date.encode(day), index) ns_day['url'] = '%s%s' % (base_url, params) ns_day['events'] = self.get_events(day, method, timetable, resource_name=resource_name, show_conflicts=show_conflicts) ns_days.append(ns_day) | def get_timetables_ns(self, start, method='weekly_view', resource_name=None, ndays=7, show_conflicts=False): ns = [] # Initialize url and parameters base_url = ';edit_event_form?' if resource_name: base_url = '%s/;edit_event_form?' % resource_name base_param = '' if method: base_param = '&method=%s&' % method # Get tim... |
ns_day = {} ns_day['nday'] = day.day ns_day['selected'] = (day == c_date) ns_day['url'] = ';edit_event_form?date=%s' % Date.encode(day) ns_day['events'] = self.get_events(day, 'monthly_view') ns_week['days'].append(ns_day) if day.day == 1: month = self.gettext(self.months[day.month]) ns_week['month'] = month | if d < ndays: ns_day = {} ns_day['nday'] = day.day ns_day['selected'] = (day == c_date) ns_day['url'] = ';edit_event_form?date=%s' % Date.encode(day) ns_day['events'] = self.get_events(day, 'monthly_view') ns_week['days'].append(ns_day) if day.day == 1: month = self.gettext(self.months[day.month]) ns_week['month'] = mo... | def monthly_view(self, context): context = get_context() root = context.root |
context = get_context() root = context.root views = ['browse_thumbnails', 'new_resource_form', 'edit_form'] | views = ['welcome', 'browse_thumbnails', 'new_resource_form', 'edit_form'] root = get_context().root | def get_views(self): context = get_context() root = context.root |
try: reviewers = root.get_handler('reviewers') except LookupError: is_rev = False else: is_rev = self.name in reviewers.get_usernames() | is_rev = self.name in root.get_handler('reviewers').get_usernames() | def get_views(self): context = get_context() root = context.root |
s.append(node) | s.append(node.replace('<', '<')) | def to_unicode(cls, value, encoding='UTF-8'): s = [] for node in value: if isinstance(node, unicode): s.append(node) else: s.append(node.to_unicode(encoding=encoding)) return u''.join(s) |
s.append(node.replace('<', '<')) | s.append(node.replace('&', '&').replace('<', '<')) | def to_unicode(cls, value, encoding='UTF-8'): s = [] for node in value: if isinstance(node, unicode): # XXX This is equivalent to 'handlers.IO.Unicode.to_unicode', # there should be a single place. s.append(node.replace('<', '<')) else: s.append(node.to_unicode(encoding=encoding)) return u''.join(s) |
self.socker.sendall(self.out_buffer) | self.socket.sendall(self.out_buffer) | def flush(self): if self.out_buffer: self.socker.sendall(self.out_buffer) self.out_buffer = '' |
return urlunsplit((self.scheme, str(self.authority), path, str(self.query), self.fragment)) | reference = urlunsplit((self.scheme, str(self.authority), path, str(self.query), self.fragment)) if reference == '': return '.' return reference | def __str__(self): path = str(self.path) if path == '.': path = '' return urlunsplit((self.scheme, str(self.authority), path, str(self.query), self.fragment)) |
config.set('instance', 'root', options.root) | config.set('instance', 'modules', options.root) | def init(parser, options, target): try: os.mkdir(target) except OSError: parser.error('can not create the instance (check permissions)') # Create the config file config = get_config() if options.root: config.set('instance', 'root', options.root) if options.port: config.set('instance', 'port', options.port) config.writ... |
if config.has_option('instance', 'modules'): for name in config.get('instance', 'modules').split(): name = name.strip() exec('import %s' % name) | def start(parser, options, target): # Load the config config = get_config(target) # Import the root class if is not the default if config.has_option('instance', 'root'): exec('import %s' % config.get('instance', 'root')) # Load the root handler database = get_database(target) root = get_root(database) root.name = roo... | |
if config.has_option('instance', 'modules'): for name in config.get('instance', 'modules').split(): name = name.strip() exec('import %s' % name) | def update(parser, options, target): # Load the config config = get_config(target) # Import the root class if is not the default if config.has_option('instance', 'root'): exec('import %s' % config.get('instance', 'root')) # Load the root resource database = get_database(target) root = get_root(database) instance_ver... | |
try: while True: | while True: try: | def start(self): if self.pid_file is not None: pid = os.getpid() open(self.pid_file, 'w').write(str(pid)) |
except: ear.close() if self.access_log is not None: self.access_log.close() if self.error_log is not None: self.error_log.close() | except KeyboardInterrupt: ear.close() if self.access_log is not None: self.access_log.close() if self.error_log is not None: self.error_log.close() break except: self.log_error() | def start(self): if self.pid_file is not None: pid = os.getpid() open(self.pid_file, 'w').write(str(pid)) |
context = get_context() request, user = context.request, context.user user = context.user | def log_error(self): context = get_context() request, user = context.request, context.user | |
error_log.write('uri : %s\n' % str(context.uri)) error_log.write('referrer: %s\n' % str(request.referrer)) error_log.write('user : %s\n' % (user and user.name or None)) | context = get_context() if context is not None: request = context.request user = context.user error_log.write('uri : %s\n' % str(context.uri)) error_log.write('referrer: %s\n' % str(request.referrer)) error_log.write('user : %s\n' % (user and user.name or None)) | def log_error(self): context = get_context() request, user = context.request, context.user |
data = '<?xml version="1.0" encoding="UTF-8"?>\n' \ '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"\n' \ ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' \ '<html xmlns="http://www.w3.org/1999/xhtml">\n' \ ' <head>\n' \ ' <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />... | data = ('<?xml version="1.0" encoding="UTF-8"?>\n' '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"\n' ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' '<html xmlns="http://www.w3.org/1999/xhtml">\n' ' <head>\n' ' <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />\n' ' ... | def get_skeleton(self, title=''): data = '<?xml version="1.0" encoding="UTF-8"?>\n' \ '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"\n' \ ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n' \ '<html xmlns="http://www.w3.org/1999/xhtml">\n' \ ' <head>\n' \ ' <meta http-equiv="Content-Type" con... |
if name.startswith('.'): if name.endswith('.metadata'): return Metadata(uri) elif name.endswith('.lock'): return Lock(uri) | if name.endswith('.metadata'): return Metadata(uri) if name.endswith('.lock'): return Lock(uri) | def _get_handler(self, segment, uri): name = segment.name # Metadata if name.startswith('.'): if name.endswith('.metadata'): return Metadata(uri) elif name.endswith('.lock'): return Lock(uri) # Get the format if self.has_handler('%s.metadata' % name): metadata = self.get_handler('%s.metadata' % name) format = metadata.... |
date = '' | v_items = [] | def edit_event(self, context): if context.has_form_value('remove'): return self.remove(context) |
date = date + context.get_form_value('DTSTART_%s' % item) | v_items.append(context.get_form_value('DTSTART_%s' % item)) date = '-'.join(v_items) if context.has_form_value('cancel'): goto = goto + '?date=' + date return context.come_back('', goto) | def edit_event(self, context): if context.has_form_value('remove'): return self.remove(context) |
uid = context.get_form_value('UID') | def remove(self, context): uid = context.get_form_value('UID') method = context.get_form_value('method', 'monthly_view') icalendar.remove(self, 'VEVENT', uid) goto = ';%s?%s' % (method, self.get_current_date()) if method not in dir(self): goto = '../;%s?%s' % (method, self.get_current_date()) return context.come_back(u... | |
icalendar.remove(self, 'VEVENT', uid) | def remove(self, context): uid = context.get_form_value('UID') method = context.get_form_value('method', 'monthly_view') icalendar.remove(self, 'VEVENT', uid) goto = ';%s?%s' % (method, self.get_current_date()) if method not in dir(self): goto = '../;%s?%s' % (method, self.get_current_date()) return context.come_back(u... | |
msg = msg % (str(expression), content.__class__.__name__) | msg = msg % {'expr': str(expression), 'type': content.__class__.__name__} | def process1(self, node, stack, repeat): """ Process stl:if, stl:ifnot, stl:attributes and stl:content. """ attrs = node.attributes stl_uri = 'http://xml.itools.org/namespaces/stl' stl_attrs = attrs.namespaces.get(stl_uri, {}) |
a//b/c : a/b/c a/./b/c : a/b/c a/b/c/../d : a/b/d /../a/b/c : /a/b/c . : XXX ? | 'a//b/c' -> 'a/b/c' 'a/./b/c' -> 'a/b/c' 'a/b/c/../d' -> 'a/b/d' '/../a/b/c ' -> '/a/b/c' '.' -> '' | def normalize_path(path): """ Normalize the path (we don't use os.path because on Windows it converts forward slashes to back slashes). Examples: a//b/c : a/b/c a/./b/c : a/b/c a/b/c/../d : a/b/d /../a/b/c : /a/b/c . : XXX ? """ if not isinstance(path, str) and not isinstance(path, unicode): raise Ty... |
documents.sort() return documents[-1] + 1 | if documents: documents.sort() return documents[-1] + 1 return 0 | def get_new_document_number(self): documents = [ int(x[1:]) for x in self.resource.get_resources() if x.startswith('d') ] documents.sort() return documents[-1] + 1 |
return self.get_end_tag(self) | return self.get_end_tag() | def get_end_tag_as_html(self): if self.name in empty_elements: return '' return self.get_end_tag(self) |
resource.truncate() | resource.truncate(0) | def _save_state(self, resource): resource.truncate() resource.write(self.to_str()) |
key, value = x.split('=', 1) dict.__setitem__(self, key, value) | if x: key, value = x.split('=', 1) dict.__setitem__(self, key, value) | def __init__(self, query): if query: for x in query.split('&'): key, value = x.split('=', 1) dict.__setitem__(self, key, value) |
version = "0.8.X", | version = "0.8.0", | def finalize_options (self): self.set_undefined_options('install', ('install_purelib', 'install_dir'), ('root', 'root'), ('force', 'force'), ) |
namespaces.set_namespace(namespaces.dublin_core, Namespace) | namespaces.set_namespace(namespaces.dublin_core, Namespace, prefix='dc') | def get_element(cls, prefix, name): if name not in schema: raise XML.XMLError, 'unknown property "%s"' % name return Element(prefix, name) |
skeleton['.archive'] = handlers.Folder.Folder() | skeleton['.archive'] = FolderHandler() | def get_skeleton(self, username=None, password=None): # First call the parent's get_skeleton users = [username] skeleton = WebSite.get_skeleton(self, admins=users) # The catalog, index and search skeleton['.catalog'] = Catalog(fields=self._catalog_fields) # The archive is used for versioning skeleton['.archive'] = hand... |
return handlers.Folder.Folder(resource) | return FolderHandler(resource) | def _get_handler(self, segment, resource): name = segment.name |
def update_20060424(self): | def update_20060503(self): stack = [self.resource] while stack: folder = stack.pop() for name in folder.get_resource_names(): resource = folder.get_resource(name) if name.endswith('.metadata') and name != '.metadata': folder.del_resource(name) folder.set_resource(name[1:], resource) elif name.startswith('.'): contin... | def update_20060424(self): # Add '.admins.users' admins = self.get_handler('admins/.users').get_usernames() self.set_handler('.admins.users', ListOfUsers(users=admins)) # Remove handlers self.del_handler('.users') self.del_handler('admins') self.del_handler('.admins.metadata') self.del_handler('reviewers') self.del_han... |
def update_20060430(self): stack = [self] while stack: folder = stack.pop() for name in folder.get_handler_names(): handler = folder.get_handler(name) if isinstance(handler, Metadata) and name != '.metadata': folder.del_handler(name) short_name, type, language = FileName.decode(name[1:-9]) folder.set_handler(name[1:],... | def update_20060424(self): # Add '.admins.users' admins = self.get_handler('admins/.users').get_usernames() self.set_handler('.admins.users', ListOfUsers(users=admins)) # Remove handlers self.del_handler('.users') self.del_handler('admins') self.del_handler('.admins.metadata') self.del_handler('reviewers') self.del_han... | |
elif isinstance(content, int): | elif isinstance(content, (int, long)): | def process1(self, node, stack, repeat): """ Process stl:if, stl:attributes and stl:content. """ # Remove the element if the given expression evaluates to false if node.has_attribute(stl_uri, 'if'): stl_expression = node.get_attribute(stl_uri, 'if') if not stl_expression.evaluate(stack, repeat): return [] |
def __init__(self, storage): self.database = ZODB.DB(storage) self.connections = {} self.lock = thread.allocate_lock() | def setUp(self): storage = FileStorage('test_db.fs') self.database = zodb.DataBase(storage) | def __init__(self, storage): self.database = ZODB.DB(storage) self.connections = {} self.lock = thread.allocate_lock() |
def get_resource(self, path): if isinstance(path, str): path = Path(path) | def test_add_file(self): root = self.database.get_resource('/') resource = memory.File('hello') root.set_resource('test.txt', resource) | def get_resource(self, path): # Pre-process input data if isinstance(path, str): path = Path(path) |
ident = thread.get_ident() if ident in self.connections: connection = self.connections[ident] else: connection = self.database.open() self.lock.acquire() try: self.connections[ident] = connection finally: self.lock.release() if not path: return Folder(connection, path) object = connection.root() for segment in path... | new_resource = root.get_resource('test.txt') self.assertEqual(new_resource.read(), 'hello') | def get_resource(self, path): # Pre-process input data if isinstance(path, str): path = Path(path) |
class Resource(base.Resource): def __init__(self, connection, path): self.connection = weakref.ref(connection) self.path = path def _get_object(self): connection = self.connection() object = connection.root() for segment in self.path: try: object = object[segment.name] except KeyError: raise LookupError, 'object "%s... | if __name__ == '__main__': unittest.main() | def get_resource(self, path): # Pre-process input data if isinstance(path, str): path = Path(path) |
start_local_import() from resources import get_resource from handlers.config import Config end_local_import() | try: from itools.resources import get_resource from handlers.config import Config except ImportError: start_local_import() from resources import get_resource from handlers.config import Config end_local_import() | def setup(description='', classifiers=[]): from __init__ import __version__ # START HACK start_local_import() from resources import get_resource from handlers.config import Config end_local_import() # END HACK config = Config(get_resource('setup.conf')) # The package name package_name = config.get_value('name') # Th... |
subpackages = config.get_value('packages').split() | def setup(description='', classifiers=[]): from __init__ import __version__ # START HACK start_local_import() from resources import get_resource from handlers.config import Config end_local_import() # END HACK config = Config(get_resource('setup.conf')) # The package name package_name = config.get_value('name') # Th... | |
for subpackage_name in subpackages: packages.append('%s.%s' % (package_name, subpackage_name)) | if config.has_value('packages'): subpackages = config.get_value('packages').split() for subpackage_name in subpackages: packages.append('%s.%s' % (package_name, subpackage_name)) | def setup(description='', classifiers=[]): from __init__ import __version__ # START HACK start_local_import() from resources import get_resource from handlers.config import Config end_local_import() # END HACK config = Config(get_resource('setup.conf')) # The package name package_name = config.get_value('name') # Th... |
scripts = config.get_value('scripts').split() scripts = [ os.path.join(*['scripts', x]) for x in scripts ] | if config.has_value('scripts'): scripts = config.get_value('scripts').split() scripts = [ os.path.join(*['scripts', x]) for x in scripts ] else: scripts = [] | def setup(description='', classifiers=[]): from __init__ import __version__ # START HACK start_local_import() from resources import get_resource from handlers.config import Config end_local_import() # END HACK config = Config(get_resource('setup.conf')) # The package name package_name = config.get_value('name') # Th... |
for handler, context in self.traverse2(): | for handler, ctx in self.traverse2(): | def update_catalog(self, context): # Initialize a new empty catalog t0 = time() transaction = get_transaction() # Init transaction (because we use sub-transactions) server = context.server server.start_commit() |
if name.startswith('.'): context.skip = True elif abspath == '/ui': context.skip = True elif handler.real_handler is not None and not abspath == '/ui': context.skip = True elif not name.startswith('.'): print n, abspath catalog.index_document(handler.get_catalog_indexes()) n += 1 if n % 1000 == 0: transaction.commit() | if handler.real_handler is not None: ctx.skip = True continue if not isinstance(handler, CatalogAware): ctx.skip = True continue print n, abspath catalog.index_document(handler.get_catalog_indexes()) n += 1 if n % 1000 == 0: transaction.commit() | def update_catalog(self, context): # Initialize a new empty catalog t0 = time() transaction = get_transaction() # Init transaction (because we use sub-transactions) server = context.server server.start_commit() |
class_version = '20040723' | class_version = '20050506' | def _get_free_slot(self): """ Internal method that returns a free slot. If none exists a new one is allocated. |
base = 12 + slot_number * 12 first_empty_link = r[base+8:base+12] | base = 12 + slot_number * 16 first_empty_link = r[base+12:base+16] | def _get_free_slot(self): """ Returns the slot number of a free slot, allocates a new one if needed. """ state = self.state r = self.resource if state.first_empty is None: slot_number = state.number_of_slots # Increment the number of slots state.number_of_slots += 1 r[4:8] = IO.encode_uint32(state.number_of_slots) else... |
base = 12 + slot_number * 12 | base = 12 + slot_number * 16 | def _get_document_slot(self, slot_number, document_number): """ Searches and returns the slot number for the given document, starting from the given base slot. If it is not found None is returned. """ r = self.resource while True: base = 12 + slot_number * 12 x = IO.decode_uint32(r[base:base+4]) if x == document_number... |
slot_number = IO.decode_link(r[base+8:base+12]) | slot_number = IO.decode_link(r[base+12:base+16]) | def _get_document_slot(self, slot_number, document_number): """ Searches and returns the slot number for the given document, starting from the given base slot. If it is not found None is returned. """ r = self.resource while True: base = 12 + slot_number * 12 x = IO.decode_uint32(r[base:base+4]) if x == document_number... |
doc_slot = 12 + doc_slot_n * 12 doc_slot_data = doc_rsrc[doc_slot:doc_slot+12] | doc_slot = 12 + doc_slot_n * 16 doc_slot_data = doc_rsrc[doc_slot:doc_slot+16] | def load_documents(self): # Initialize data structure self.documents = {} |
doc_slot_n = IO.decode_link(doc_slot_data[8:12]) | pos_slot_n = IO.decode_link(doc_slot_data[8:12]) doc_slot_n = IO.decode_link(doc_slot_data[12:16]) | def load_documents(self): # Initialize data structure self.documents = {} |
for i in range(frequency): documents.append(None) | while pos_slot_n is not None: pos_slot = 12 + pos_slot_n * 8 position = IO.decode_uint32(posi_rsrc[pos_slot:pos_slot+4]) documents.append(position) pos_slot_n = IO.decode_link(posi_rsrc[pos_slot+4:pos_slot+8]) | def load_documents(self): # Initialize data structure self.documents = {} |
doc_slot = 12 + doc_slot_n * 12 | doc_slot = 12 + doc_slot_n * 16 | def _index_term(self, term, documents): """ Indexes the given term. The parameter 'documents' is a mapping from document number to list of positions: |
doc_slot = 12 + doc_slot_n * 12 docs_rsrc[doc_slot:doc_slot+12] = ( | doc_slot = 12 + doc_slot_n * 16 docs_rsrc[doc_slot:doc_slot+16] = ( | def _index_term(self, term, documents): """ Indexes the given term. The parameter 'documents' is a mapping from document number to list of positions: |
docs_slot = 12 + docs_slot_n * 12 | docs_slot = 12 + docs_slot_n * 16 | def _unindex_term(self, word, documents): """ Un-indexes the given term. The parameter 'documents' is a list with the numbers of the documents that must be un-indexed. """ if word: if self.children is None: self.load_children() |
next_slot_r = docs_rsrc[docs_slot+8:docs_slot+12] | next_slot_r = docs_rsrc[docs_slot+12:docs_slot+16] | def _unindex_term(self, word, documents): """ Un-indexes the given term. The parameter 'documents' is a list with the numbers of the documents that must be un-indexed. """ if word: if self.children is None: self.load_children() |
('documents', IIndexDocuments())] | ('documents', IIndexDocuments()), ('positions', IIndexPositions())] | def get_skeleton(self): return [('tree', IIndexTree()), ('documents', IIndexDocuments())] |
stack.append(element_class(None, value)) | stack.append(element_class(value)) | def _load_state(self, resource): state = self.state state.encoding = 'UTF-8' state.document_type = None state.children = [] |
def get_languages(self): | def get_languages(cls): | def get_languages(self): return NotImplementedError |
def select_language(self, languages=None): | def select_language(cls, languages=None): | def select_language(self, languages=None): if languages is None: languages = self.get_languages() |
languages = self.get_languages() | languages = cls.get_languages() | def select_language(self, languages=None): if languages is None: languages = self.get_languages() |
def gettext(self, message, language=None, domain=None): | def gettext(cls, message, language=None, domain=None): | def gettext(self, message, language=None, domain=None): if domain is None: domain = self.class_domain |
domain = self.class_domain | domain = cls.class_domain | def gettext(self, message, language=None, domain=None): if domain is None: domain = self.class_domain |
language = self.select_language(languages) | language = cls.select_language(languages) | def gettext(self, message, language=None, domain=None): if domain is None: domain = self.class_domain |
value = XML.encode(value) | if datatype is not Record: value = XML.encode(value) | def to_str(self): state = self.state |
def encode(self): | def encode(self, encoding='UTF-8'): | def encode(self): schema = self.schema data = u'' |
data = u'' | lines = [] | def encode(self): schema = self.schema data = u'' |
value = type.encode(value) value = unicode(value, 'utf8') data += u'<%s lang="%s">%s</%s>\n' \ % (name, language, value, name) | if issubclass(type, IO.Unicode): value = type.encode(value, encoding) elif issubclass(type, ComplexType): value = type.encode(value, encoding) else: value = type.encode(value) lines.append('<%s lang="%s">%s</%s>\n' % (name, language, value, name)) | def encode(self): schema = self.schema data = u'' |
value = type.encode(value) | if issubclass(type, IO.Unicode): value = type.encode(value, encoding) elif issubclass(type, ComplexType): value = type.encode(value, encoding) else: value = type.encode(value) | def encode(self): schema = self.schema data = u'' |
data += u'<%s>\n' % name value = [ ' %s\n' % x for x in value.splitlines() ] data += ''.join(value) data += u'</%s>\n' % name | lines.append('<%s>\n' % name) for line in value.splitlines(): lines.append(' %s\n' % line) lines.append('</%s>\n' % name) | def encode(self): schema = self.schema data = u'' |
data += u'<%s>%s</%s>\n' % (name, value, name) return data | lines.append('<%s>%s</%s>\n' % (name, value, name)) return ''.join(lines) | def encode(self): schema = self.schema data = u'' |
print "OfficeDocument.to_text" | def to_text(self): if self.__text_output__ is not None: return self.__text_output__ print "OfficeDocument.to_text" | |
print "html", html | def to_text(self): if self.__text_output__ is not None: return self.__text_output__ print "OfficeDocument.to_text" | |
print "resource", resource | def to_text(self): if self.__text_output__ is not None: return self.__text_output__ print "OfficeDocument.to_text" | |
print "handler", handler | def to_text(self): if self.__text_output__ is not None: return self.__text_output__ print "OfficeDocument.to_text" | |
print "text", text | def to_text(self): if self.__text_output__ is not None: return self.__text_output__ print "OfficeDocument.to_text" | |
print "OfficeDocument.to_html" | def to_html(self, outfile=None): if self.__html_output__ is not None: return self.__html_output__ print "OfficeDocument.to_html" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.