rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
print "Warning html of file not converted: %s" % stderr | def to_html(self, outfile=None): if self.__html_output__ is not None: return self.__html_output__ print "OfficeDocument.to_html" | |
print "encoding", encoding | def to_html(self, outfile=None): if self.__html_output__ is not None: return self.__html_output__ print "OfficeDocument.to_html" | |
print "OOffice.to_text" | def to_text(self, outfile=None): if self.__text_output__ is not None: return self.__text_output__ print "OOffice.to_text" | |
print "OOffice.to_html" | def to_html(self): print "OOffice.to_html" raise NotImplementedError | |
return '&'.join([ '%s=%s' % (k, v) for k, v in self.items() ]) | return '&'.join([ '%s=%s' % (k, urllib.quote_plus(v)) for k, v in self.items() ]) | def __str__(self): return '&'.join([ '%s=%s' % (k, v) for k, v in self.items() ]) |
real = self.real_handler or self if real.get_abspath().startswith('/ui'): format = vfs.get_mimetype(uri) cls = get_object_class(format) return cls(uri) | from skins import UI x = self while x: if isinstance(x, UI): format = vfs.get_mimetype(uri) cls = get_object_class(format) return cls(uri) x = x.parent | def _get_handler(self, segment, uri): name = segment.name # Metadata if name.endswith('.metadata'): return Metadata(uri) # Locks if name.endswith('.lock'): return Lock(uri) |
if os.path.exists(folder_path): if os.path.exists(file_path): | if exists(folder_path): if exists(file_path): | def make_file(reference): folder_path = str(reference.path[:-1]) file_path = str(reference.path) |
mimetype = file.get_mimetype() | name, mimetype, body = file | def upload_file(self, context): file = context.get_form_value('file') if file is None: return context.come_back(u'The file must be entered') |
name = file.name | def upload_file(self, context): file = context.get_form_value('file') if file is None: return context.come_back(u'The file must be entered') | |
file.open() data = file.read() file.close() encoding = Text.guess_encoding(data) data = unicode(data, encoding) | encoding = Text.guess_encoding(body) data = unicode(body, encoding) | def upload_file(self, context): file = context.get_form_value('file') if file is None: return context.come_back(u'The file must be entered') |
handler = build_handler(file) | handler_class = get_object_class(mimetype) handler = handler_class() handler.load_state_from_string(body) | def upload_file(self, context): file = context.get_form_value('file') if file is None: return context.come_back(u'The file must be entered') |
new_query.append(('%s:utf8:ustring' % key, value)) | new_query.append(('%s' % key, value)) | def build_url(self, url=None, preserve=[], **kw): """ Builds and returns a new url from the one we are now. Preserves only the query parameters that start with any of the specified prefixes in the 'preserve' argument. The keywords argument is used to add or modify query parameters. """ if url is None: url = self.path[-... |
new_query.append(('%s:int' % key, str(value))) | new_query.append(('%s' % key, str(value))) | def build_url(self, url=None, preserve=[], **kw): """ Builds and returns a new url from the one we are now. Preserves only the query parameters that start with any of the specified prefixes in the 'preserve' argument. The keywords argument is used to add or modify query parameters. """ if url is None: url = self.path[-... |
* itools.xml -- XML infrastructure, includes resource handlers for XML and the Simple Template Language. | * itools.xml -- includes an intuitive event driven XML parser, a handler for XML documents, and the Simple Template Language. | def finalize_options (self): self.set_undefined_options('install', ('install_purelib', 'install_dir'), ('root', 'root'), ('force', 'force'), ) |
def get_head(self): """ Returns the head element. """ root = self.get_root_element() heads = [ x for x in root.get_elements() if x.name == 'head' ] if heads: return heads[0] return None def get_body(self): """ Returns the body element. """ root = self.get_root_element() bodies = [ x for x in root.get_elements() if x.... | 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... | |
def get_head(self): """ Returns the head element. """ root = self.get_root_element() heads = [ x for x in root.get_elements() if x.name == 'head' ] if heads: return heads[0] return None def get_body(self): """ Returns the body element. """ root = self.get_root_element() bodies = [ x for x in root.get_elements() if x.... | def resolve_pointer(self, uri, offset): if uri.path.is_relative(): return offset.resolve(uri.path) return uri def set_template_prefix(self, offset): data = [] data.append(self.header_to_unicode()) for node, context in self.traverse2(): if isinstance(node, XML.Element): if context.start: data.append(u'<%s' % nod... | def get_head(self): """ Returns the head element. """ root = self.get_root_element() heads = [ x for x in root.get_elements() if x.name == 'head' ] if heads: return heads[0] return None |
views = ['welcome', 'browse_thumbnails', 'new_resource_form', | views = ['profile', 'browse_thumbnails', 'new_resource_form', | def get_views(self): views = ['welcome', 'browse_thumbnails', 'new_resource_form', 'edit_form'] # Task list only for reviewers and admins (for now). root = get_context().root is_admin = self.name in root.get_handler('admins').get_usernames() is_rev = self.name in root.get_handler('reviewers').get_usernames() if is_admi... |
welcome__access__ = 'is_allowed_to_view' welcome__label__ = u'Welcome' def welcome(self): | profile__access__ = 'is_allowed_to_view' profile__label__ = u'Profile' def profile(self): context = get_context() root = context.root user = context.user | def clear_group_cache(self): self._groups = None |
root = get_context().root is_admin = self.name in root.get_handler('admins').get_usernames() is_rev = self.name in root.get_handler('reviewers').get_usernames() namespace['tasks'] = is_admin or is_rev handler = self.get_handler('/ui/User_welcome.xml') | is_owner = user is not None and user.name == self.name namespace['is_owner'] = is_owner is_admin = user.name in root.get_handler('admins').get_usernames() namespace['is_owner_or_admin'] = is_owner or is_admin handler = self.get_handler('/ui/User_profile.xml') | def welcome(self): namespace = {} namespace['title'] = self.get_property('dc:title') or self.name # Tasks? (for now). root = get_context().root is_admin = self.name in root.get_handler('admins').get_usernames() is_rev = self.name in root.get_handler('reviewers').get_usernames() namespace['tasks'] = is_admin or is_rev |
create_catalog() load_documents() | load_catalog() | def search_documents(): for word in ('forget', 'lion', 'hit'): catalog.search(body=word) |
active = name == context.method | active = name == context.method or name in subviews | def get_tabs(self, context): """ Return tabs and subtabs as a dict {tabs, subtabs} of list of dicts [{name, label, active, style}...]. """ # Get request, path, etc... request = context.request user = context.user here = context.handler if here is None: return {'tabs': [], 'subtabs': []} |
for x in child.traverse(): yield x | if isinstance(child, Element): for x in child.traverse(): yield x else: yield child | def traverse(self): yield self for child in self.children: for x in child.traverse(): yield x |
for i, task in enumerate(self.tasks): | for i, task in enumerate(self.state.tasks): | def view(self): # Load the STL template handler = get_handler('TaskTracker_view.xml') |
resource = handler.resource if resource.get_mtime() is not None: resource.open() handler._save_state(resource) resource.close() handler.timestamp = resource.get_mtime() | mtime = vfs.get_mtime(handler.uri) if mtime is not None: handler.save_state() | def commit(self, username='', note=''): if not self: return |
message = "'%s' object has no attribute '%s'" | def __getattr__(self, name): try: column = self.columns.index(name) except ValueError: message = "'%s' object has no attribute '%s'" raise AttributeError, message % (self.__class__.__name__, name) | |
version = "0.9.3", | version = "0.10.0", | def finalize_options (self): self.set_undefined_options('install', ('install_purelib', 'install_dir'), ('root', 'root'), ('force', 'force'), ) |
container.set_changed() | def set_handler(self, path, handler, **kw): if not isinstance(path, uri.Path): path = uri.Path(path) | |
self.set_changed() | def del_handler(self, path): self.set_changed() | |
if name not in container.get_handler_names(): raise LookupError, 'there is not any handler named "%s"' % name | def del_handler(self, path): self.set_changed() | |
def _load(self): tree_rsrc = self.root.tree_handler.resource slot = 16 + self.slot * 16 doc_rsrc = self.root.docs_handler.resource doc_slot_n = IO.decode_link(tree_rsrc[slot+4:slot+8]) while doc_slot_n is not None: doc_slot = 12 + doc_slot_n * 12 doc_number = IO.decode_uint32(doc_rsrc[doc_slot:doc_slot+4]) self.docume... | def __init__(self, root, slot): # The root is also the resource handler. self.root = root self.slot = slot self.documents = {} self.children = {} | |
while child_n is not None: child = 16 + child_n * 16 c = IO.decode_character(tree_rsrc[child:child+4]) tree = Tree(self, child_n) self.children[c] = tree tree._load() child_n = IO.decode_link(tree_rsrc[child+12:child+16]) | if child_n is not None: stack.append((self, child_n)) while stack: parent, tree_slot_n = stack.pop() tree = Tree(self, tree_slot_n) tree_slot = 16 + tree_slot_n * 16 c = IO.decode_character(tree_rsrc[tree_slot:tree_slot+4]) parent.children[c] = tree doc_slot_n = IO.decode_link(tree_rsrc[tree_slot+4:tree_slot+8]) ... | def _load(self, resource): Folder._load(self, resource) |
if os.path.isdir(src): | if src.endswith(catalog_path): subprocess.call(['rsync', '-a', '--delete', src + '/', dst]) elif os.path.isdir(src): | def end_commit_on_success(self): target = self.target transaction = get_transaction() abspaths = [ str(x.uri.path) for x in transaction if x.uri.scheme == 'file' ] abspaths.sort() open('%s/state' % target, 'w').write('END') try: a, b = '%s/database' % target, '%s/database.bak' % target for src in abspaths: dst = src.re... |
for filename in src_files & dst_files: srcfile = '%s/%s' % (src, filename) dstfile = '%s/%s' % (dst, filename) srctime = os.stat(srcfile).st_mtime dsttime = os.stat(dstfile).st_mtime if srctime > dsttime: vfs.remove(dstfile) vfs.copy(srcfile, dstfile) | def end_commit_on_success(self): target = self.target transaction = get_transaction() abspaths = [ str(x.uri.path) for x in transaction if x.uri.scheme == 'file' ] abspaths.sort() open('%s/state' % target, 'w').write('END') try: a, b = '%s/database' % target, '%s/database.bak' % target for src in abspaths: dst = src.re... | |
is_admin = root.is_in_role('admins', user.name) | is_admin = user is not None and root.is_in_role('admins', user.name) | def profile(self, context): root = context.root user = context.user |
raise ValueError, u'content type "%s" not supported' % type | resource = memory.File(body) handler = Handler.build_handler(resource) parameters = {'body': handler} | def _load_state(self, resource): state = self.state state.form = {} |
return unicode(head.get_elements('title')[0].children) | title = head.get_elements('title')[0] return XML.Children.to_unicode(title.children) | def title(self): head = self.get_head() return unicode(head.get_elements('title')[0].children) |
print 'Stopped. | print 'Stopped.' | def stop(parser, options, target): pid = open('%s/pid' % target).read() pid = int(pid) os.kill(pid, signal.SIGTERM) print 'Stopped. |
'dc:title': email}) | 'dc:title': {'en': email}}) | def set_user(self, email, password): user = User() |
def decode(cls, data): | def decode(data): | def decode(cls, data): raise NotImplementedError |
return [] | return {} | def search_word(self, word): if word: prefix, suffix = word[0], word[1:] subtree = self.children.get(prefix, None) if subtree is None: return [] else: return subtree.search_word(suffix) else: documents = [] for doc_number, positions in self.documents.items(): weight = len(positions) documents.append((weight, doc_number... |
documents = [] | documents = {} | def search_word(self, word): if word: prefix, suffix = word[0], word[1:] subtree = self.children.get(prefix, None) if subtree is None: return [] else: return subtree.search_word(suffix) else: documents = [] for doc_number, positions in self.documents.items(): weight = len(positions) documents.append((weight, doc_number... |
documents.append((weight, doc_number)) documents.sort() documents.reverse() return [ y for x, y in documents ] | documents[doc_number] = weight return documents | def search_word(self, word): if word: prefix, suffix = word[0], word[1:] subtree = self.children.get(prefix, None) if subtree is None: return [] else: return subtree.search_word(suffix) else: documents = [] for doc_number, positions in self.documents.items(): weight = len(positions) documents.append((weight, doc_number... |
documents = [] | documents = {} | def search(self, **kw): documents = [] for key, value in kw.items(): if key in self.indexed_fields: tree = self.indexed_fields[key] for doc_number in tree.search_word(value): # Calculate the document index document_numbers = self.documents.keys() document_numbers.sort() doc_index = document_numbers.index(doc_number) # ... |
for doc_number in tree.search_word(value): document_numbers = self.documents.keys() document_numbers.sort() doc_index = document_numbers.index(doc_number) stored_fields = self.fdt.documents[doc_index] document = Document(doc_number) for field_number, tokenized, value in stored_fields: field_name = self.field_names[f... | for doc_number, weight in tree.search_word(value).items(): documents.setdefault(doc_number, 0) documents[doc_number] += weight documents = [ (weight, doc_number) for doc_number, weight in documents.items() ] documents.sort() documents.reverse() document_numbers = self.documents.keys() document_numbers.sort() for i, ... | def search(self, **kw): documents = [] for key, value in kw.items(): if key in self.indexed_fields: tree = self.indexed_fields[key] for doc_number in tree.search_word(value): # Calculate the document index document_numbers = self.documents.keys() document_numbers.sort() doc_index = document_numbers.index(doc_number) # ... |
self.assertEqual(ref.query, 'query') | self.assertEqual(ref.query, {'query': None}) | def test_full(self): ref = 'http://example.com/a/b/c?query#fragment' ref = generic.decode(ref) self.assertEqual(ref.scheme, 'http') self.assertEqual(ref.authority, 'example.com') self.assertEqual(ref.path, '/a/b/c') self.assertEqual(ref.query, 'query') self.assertEqual(ref.fragment, 'fragment') |
self.assertEqual(ref.query, 'query') | self.assertEqual(ref.query, {'query': None}) | def test_query(self): ref = '?query' ref = generic.decode(ref) self.assertEqual(bool(ref.scheme), False) self.assertEqual(bool(ref.authority), False) self.assertEqual(len(ref.path), 0) self.assertEqual(ref.query, 'query') |
version = "0.4.6", | version = "0.5.0", | 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" |
s.append(self.get_start_tag()) s.append(self.get_content_as_html()) s.append(self.get_end_tag_as_html()) | s.append(node.get_start_tag()) s.append(node.get_content_as_html()) s.append(node.get_end_tag_as_html()) | def get_content_as_html(self, encoding='UTF-8'): s = [] for node in self.children: if isinstance(node, unicode): # XXX This is equivalent to 'types.Unicode.to_unicode', # there should be a single place. s.append(node.replace('&', '&').replace('<', '<')) elif isinstance(node, Element): s.append(self.get_start_tag... |
dialect = python_csv.Sniffer().sniff('\n'.join(data.splitlines()[:10])) | lines = data.splitlines() dialect = python_csv.Sniffer().sniff('\n'.join(lines[:10])) dialect.doublequote = True | def _get_csv_reader(self, data): """Build and return the csv file reader.""" dialect = python_csv.Sniffer().sniff('\n'.join(data.splitlines()[:10])) if dialect.delimiter == '': dialect.delimiter = ',' return python_csv.reader(data.splitlines(), dialect) |
return python_csv.reader(data.splitlines(), dialect) | return python_csv.reader(lines, dialect) | def _get_csv_reader(self, data): """Build and return the csv file reader.""" dialect = python_csv.Sniffer().sniff('\n'.join(data.splitlines()[:10])) if dialect.delimiter == '': dialect.delimiter = ',' return python_csv.reader(data.splitlines(), dialect) |
self.class_version, version) | object_version, version) | def update(self, version=None, *args, **kw): # Set zero version if the object does not have a version object_version = self.metadata.get_property('version') if object_version is None: object_version = '00000000' |
userfolder = root.get_object('users') | userfolder = root.get_handler('users') | def permissions_form(self, context): root = context.root userfolder = root.get_object('users') namespace = {} |
users = [userfolder.get_object(u) for u in members] | users = [userfolder.get_handler(u) for u in members] | def permissions_form(self, context): root = context.root userfolder = root.get_object('users') namespace = {} |
userfolder = root.get_object('users') | userfolder = root.get_handler('users') | def permissions(self, context): # Permissions to remove if context.has_form_value('delete'): for username in context.get_form_values('delusers'): self.del_roles(username) return context.come_back(u"Members deleted.") |
def _unindex_term(self, word, doc_number): | 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. """ | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... |
subtree._unindex_term(suffix, doc_number) | subtree._unindex_term(suffix, documents) | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... |
del self.documents[doc_number] | for doc_number in documents: del self.documents[doc_number] | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... |
while docs_slot_n is not None: | while documents and docs_slot_n is not None: | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... |
if x == doc_number: | if x in documents: documents.remove(x) | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... |
break | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... | |
else: raise ValueError, 'The database is corrupted!!' | def _unindex_term(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] if prefix in self.children: subtree = self.children[prefix] subtree._unindex_term(suffix, doc_number) else: del self.documents[doc_number] # Update resource tree_rsrc = self.root.tree_handler.resource docs = self.root.docs_handler do... | |
for doc_number in documents: self._unindex_term(term, doc_number) | self._unindex_term(term, documents) | def _save(self): # Removed terms for term, documents in self.removed_terms.items(): for doc_number in documents: self._unindex_term(term, doc_number) self.removed_terms = {} # Added terms for term, documents in self.added_terms.items(): self._index_term(term, documents) |
value = self.request.get_parameter(name) if isinstance(value, list): return value return [value] | request = self.request if request.has_parameter(name): value = request.get_parameter(name) if isinstance(value, list): return value return [value] return [] | def get_form_values(self, name): value = self.request.get_parameter(name) if isinstance(value, list): return value return [value] |
def has_parameter(self, name): | def has_form_value(self, name): | def has_parameter(self, name): return self.request.has_parameter(name) |
reference = decode(reference) | reference = GenericDataType.decode(reference) | def resolve(self, reference): """ Resolve the given relative URI, this URI (self) is considered to be the base. |
reference = decode(reference) | reference = GenericDataType.decode(reference) | def resolve2(self, reference): """ This is much like 'resolv', but uses 'Path.resolve2' method instead. |
s = [] s.append(document.header_to_unicode()) s.extend(self.process(document.root_element, stack, repeat)) | s = self.process(document.root_element, stack, repeat) | def __call__(self, namespace={}): # XXX Rewrite with traverse2. |
gettext = self.handler.gettext(message) | message = self.handler.gettext(message) | def come_back(self, message, goto=None, **kw): # Translate the source message, gettext = self.handler.gettext(message) message = Template(message).substitute(kw) # Build and the return the uri reference to go if goto is None: goto = self.request.referrer else: goto = uri.get_reference(goto) return goto.replace(message=... |
for j in idx: if j > row_number: j = j - 1 new_idx[j] = idx[j] | for number in idx: if number > row_number: new_number = number - 1 else: new_number = number new_idx[new_number] = idx[number] | def _unindex_row(self, row_number): """Unindex deleted row""" # XXX We should un-index directly looking from the row values, as # the commented code below shows. The difficulty comes from the # fact that row numbers change when a row before is deleted; in # other words, when we remove a row, we must re-index all rows #... |
namespace = self.browse_namespace(48, batchsize='0') table = namespace['table'] | query = queries.Equal('parent_path', self.get_abspath()) namespace = self.browse_namespace(48, query=query, batchsize=0) | def browse_image(self, context): selected_image = context.get_form_value('selected_image') selected_index = None |
for index, object in enumerate(table.objects): | for index, object in enumerate(namespace['objects']): | def browse_image(self, context): selected_image = context.get_form_value('selected_image') selected_index = None |
object['url'] = '?selected_image=%s' % name object['icon'] = '%s/;icon48?width=128&height=128' % name | object['name'] = name | def browse_image(self, context): selected_image = context.get_form_value('selected_image') selected_index = None |
table.objects = objects | namespace['objects'] = objects | def browse_image(self, context): selected_image = context.get_form_value('selected_image') selected_index = None |
root = context.root here = context.handler | here = context.handler root = here.get_site_root() | def get_template_title(self): """Return the title to give to the template document.""" context = get_context() root = context.root here = context.handler if root is here: return root.get_title_or_name() else: mapping = {'root_title': root.get_title_or_name(), 'here_title': here.get_title_or_name()} return here.gettext(... |
else: scheme = generic.GenericDataType | return scheme.decode(scheme_specifics) scheme = generic.GenericDataType | def get_reference(reference): """ Returns a URI reference of the good type from the given string. """ if ':' in reference: scheme_name, scheme_specifics = reference.split(':', 1) scheme = registry.get_scheme(scheme_name) else: scheme = generic.GenericDataType return scheme.decode(reference) |
if data.strip(): | if node.strip(): | def process_message(message, keep_spaces): # Normalize the message message.normalize() # Left strip if message: x = message[0] if isinstance(x, unicode) and x.strip() == u'': del message[0] # Right strip if message: x = message[-1] if isinstance(x, unicode) and x.strip() == u'': del message[-1] # Process if message: # ... |
def decode(cls, value): if not value: return None return int(value) | def to_unicode(cls, value): if value is None: return u'' return unicode(value) | def decode(cls, value): if not value: return None return int(value) |
decode = classmethod(decode) | to_unicode = classmethod(to_unicode) | def decode(cls, value): if not value: return None return int(value) |
def decode(cls, value, encoding='UTF-8'): return unicode(value, encoding) decode = classmethod(decode) | def encode(cls, value, encoding='UTF-8'): # Escape XML (XXX this is specific to XML) value = value.replace('&', '&').replace('<', '<') return value.encode(encoding) | |
def decode(cls, value): return value decode = classmethod(decode) | def encode(cls, value): return value | |
def decode(cls, value): return bool(int(value)) decode = classmethod(decode) | def decode(cls, value): return bool(int(value)) | |
def encode(cls, value): if value is None: return '' return value.strftime('%Y-%m-%d') encode = classmethod(encode) | def decode(cls, value): return bool(int(value)) | |
class DateTime(object): | def decode(cls, value): if not value: return None year, month, day = value.split('-') year, month, day = int(year), int(month), int(day) return datetime.date(year, month, day) | |
return value.strftime('%Y-%m-%d %H:%M') | return value.strftime('%Y-%m-%d') | def encode(cls, value): if value is None: return '' return value.strftime('%Y-%m-%d %H:%M') |
def decode(cls, value): return uri.get_reference(value) decode = classmethod(decode) | def decode(cls, value): return uri.get_reference(value) | |
yield XMLDataType.encode(x) | yield x | def process_message(message, keep_spaces): # Normalize the message message.normalize() # Left strip if message: x = message[0] if isinstance(x, unicode) and x.strip() == u'': del message[0] yield x # Right strip if message: x = message[-1] if isinstance(x, unicode) and x.strip() == u'': del message[-1] yield x # Proces... |
yield handler | yield resource | def traverse(self): yield self for resource_name in self.get_resources(): resource = self.get_resource(resource_name) if isinstance(resource, Folder): for x in resource.traverse(): yield x else: yield handler |
decode = classmethod(decode) def encode(cls, value): | @staticmethod def encode(value): | def decode(cls, value): pass |
encode = classmethod(encode) def to_unicode(cls, value): | @staticmethod def to_unicode(value): | def encode(cls, value): if value is None: return '' return value.strftime('%Y-%m-%d %H:%M') |
schema = {'title': {'type': types.Unicode}, 'link': {'type': types.URI}, 'description': {'type': types.Unicode}, 'language': {'type': types.Unicode}, 'copyright': {'type': types.Unicode}, 'pubDate': {'type': types.Unicode}, 'ttl': {'type': types.Integer}, 'lastBuildDate': {'type': types.Unicode}, 'generatora': {'type... | schema = {'title': Unicode, 'link': URI, 'description': Unicode, 'language': Unicode, 'copyright': Unicode, 'pubDate': Unicode, 'ttl': Integer, 'lastBuildDate': Unicode, 'generatora': Unicode, 'url': URI, 'width': Integer, 'height': Integer, 'image': String, } | def to_unicode(cls, value): if value is None: return u'' return unicode(value.strftime('%Y-%m-%d %H:%M')) |
return schema[name]['type'].decode(value) | return schema[name].decode(value) | def decode_element(self, name, value): return schema[name]['type'].decode(value) |
return schema[name]['type'].encode(value) | return schema[name].encode(value) | def encode_element(self, name, value): return schema[name]['type'].encode(value) |
docs_slot_n = docs._get_document_slot(docs_slot_n, doc_number) | def unindex_word(self, word, doc_number): if word: prefix, suffix = word[0], word[1:] subtree = self.children[prefix] subtree.unindex_word(suffix, doc_number) if len(subtree.children) == 0 and len(subtree.documents) == 0: del self.children[prefix] else: del self.documents[doc_number] # Update resource tree_rsrc = self.... | |
if not document.is_allowed_to_view(): | ac = document.get_access_control() if not ac.is_allowed_to_view(user, document): | def site_search(self, context): text = context.get_form_value('site_search_text').strip() if not text: return context.come_back(u"Empty search value.") |
url = "http://sf.net/projects/lleu", | url = "http://www.ikaaro.org", | 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" |
expr = re.compile('<body>(.*)</body>', re.I + re.S) match = expr.search(new_body) new_body = match.group() data = self.to_str() data = expr.sub(new_body, data) resource = memory.File(data) self.load_state(resource) | resource = memory.File(new_body) doc = XHTML.Document(resource) children = doc.get_body().children body = self.get_body() self.set_changed() body.children = children | def edit(self, **kw): # XXX This code is ugly. We must: (1) write our own XML parser, with # support for fragments, and (2) use the commented code. |
new_body = '<body>%s</body>' % new_body expr = re.compile('<body>(.*)</body>', re.I + re.S) data = self.to_str() data = expr.sub(new_body, data) resource = memory.File(data) self.load_state(resource) | resource = memory.File(new_body) doc = HTML.Document(resource) children = doc.get_root_element().children body = self.get_body() self.set_changed() body.children = children | def edit(self, **kw): # XXX This is copy and paste from XHTMLFile.edit (except for the # tidy part) new_body = kw['data'] new_body = '<body>%s</body>' % new_body # Replace by the new body expr = re.compile('<body>(.*)</body>', re.I + re.S) data = self.to_str() data = expr.sub(new_body, data) |
version = "0.4.5", | version = "0.4.6", | 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" |
exec('root_class = %s' % options.root) | exec('root_class = %s.Root' % 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... |
languages = [ x.split('.')[-1] for x in vfs.get_names(self.uri) | languages = [ x.split('.')[-1] for x in self.cache | def _get_virtual_handler(self, segment): name = segment.name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.