rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
lines = list(f) | try: lines = list(f) finally: f.close() | def main(argv): parser = OptionParser(usage='Usage: %prog [-v] [-i ignorepath]* [path]') parser.add_option('-v', '--verbose', dest='verbose', default=False, action='store_true') parser.add_option('-i', '--ignore-path', dest='ignored_paths', default=[], action='append') options, args = parser.parse_args(argv[1:]) if le... |
f = codecs.open(fn, 'rU', encoding) | f = codecs.EncodedFile(open(fn, 'U'), encoding) | def run(self): document = self.state.document filename = self.arguments[0] if not document.settings.file_insertion_enabled: return [document.reporter.warning('File insertion disabled', line=self.lineno)] env = document.settings.env if filename.startswith('/') or filename.startswith(os.sep): rel_fn = filename[1:] else: ... |
settings = self.document.settings | settings, source = self.document.settings, self.document['source'] | def apply(self): settings = self.document.settings parser = RSTParser() for node, msg in extract_messages(self.document): ctx = node.parent patch = new_document(msg, settings) msgstr = "Insert translation **here**." parser.parse(msgstr, patch) ctx.replace(node, patch.children) |
patch = new_document(msg, settings) | patch = new_document(source, settings) | def apply(self): settings = self.document.settings parser = RSTParser() for node, msg in extract_messages(self.document): ctx = node.parent patch = new_document(msg, settings) msgstr = "Insert translation **here**." parser.parse(msgstr, patch) ctx.replace(node, patch.children) |
result = [] | results = [] | def emit(self, event, *args): result = [] if event in self._listeners: for _, callback in self._listeners[event].iteritems(): result.append(callback(self, *args)) return result |
result.append(callback(self, *args)) return result | results.append(callback(self, *args)) return results | def emit(self, event, *args): result = [] if event in self._listeners: for _, callback in self._listeners[event].iteritems(): result.append(callback(self, *args)) return result |
staticdir = (root == path.join(outdir, '_static')) | staticdir = root.startswith(path.join(outdir, '_static')) | def build_hhx(self, outdir, outname): self.info('dumping stopword list...') f = self.open_file(outdir, outname+'.stp') try: for word in sorted(stopwords): print >>f, word finally: f.close() |
from docutils.parsers.rst.directives.misc import Include as BaseInclude | def run(self): node = addnodes.only() node.document = self.state.document node.line = self.lineno node['expr'] = self.arguments[0] self.state.nested_parse(self.content, self.content_offset, node, match_titles=1) return [node] | |
from docutils.parsers.rst.directives.misc import Class | def run(self): env = self.state.document.settings.env rel_filename, filename = env.relfn2path(self.arguments[0]) self.arguments[0] = filename return BaseInclude.run(self) | |
buf.append(u'%s = %s' % (rv, self.value)) | buf.append(u'= %s' % self.value) | def __unicode__(self): buf = self.get_modifiers() buf.append(u'%s %s' % (self.typename, self.name)) if self.value is not None: buf.append(u'%s = %s' % (rv, self.value)) return u' '.join(buf) |
title = title[dot + 2:] | title = title[dcolon + 2:] | def process_link(self, env, refnode, has_explicit_title, title, target): refnode['cpp:parent'] = env.temp_data.get('cpp:parent') if not has_explicit_title: target = target.lstrip('~') # only has a meaning for the title # if the first character is a tilde, don't display the module/class # parts of the contents if title[... |
classname. | classname. Returns a list of (name, object entry) tuples. | def find_obj(self, env, modname, classname, name, type, searchorder=0): """ Find a Python object for "name", perhaps using the given module and/or classname. """ # skip parens if name[-2:] == '()': name = name[:-2] |
if newname is None: return None, None return newname, objects[newname] | if newname is not None: matches.append((newname, objects[newname])) return matches | def find_obj(self, env, modname, classname, name, type, searchorder=0): """ Find a Python object for "name", perhaps using the given module and/or classname. """ # skip parens if name[-2:] == '()': name = name[:-2] |
typ, target, node, contnode): if (typ == 'mod' or typ == 'obj' and target in self.data['modules']): | type, target, node, contnode): if (type == 'mod' or type == 'obj' and target in self.data['modules']): | def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): if (typ == 'mod' or typ == 'obj' and target in self.data['modules']): docname, synopsis, platform, deprecated = \ self.data['modules'].get(target, ('','','', '')) if not docname: return None else: title = '%s%s%s' % ((platform and '(%s) ' %... |
name, obj = self.find_obj(env, modname, clsname, target, typ, searchorder) if not obj: | matches = self.find_obj(env, modname, clsname, target, type, searchorder) if not matches: | def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): if (typ == 'mod' or typ == 'obj' and target in self.data['modules']): docname, synopsis, platform, deprecated = \ self.data['modules'].get(target, ('','','', '')) if not docname: return None else: title = '%s%s%s' % ((platform and '(%s) ' %... |
else: return make_refnode(builder, fromdocname, obj[0], name, contnode, name) | elif len(matches) > 1: env.warn(fromdocname, 'more than one target found for cross-reference ' '%r: %s' % (target, ', '.join(match[0] for match in matches)), node.line) name, obj = matches[0] return make_refnode(builder, fromdocname, obj[0], name, contnode, name) | def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): if (typ == 'mod' or typ == 'obj' and target in self.data['modules']): docname, synopsis, platform, deprecated = \ self.data['modules'].get(target, ('','','', '')) if not docname: return None else: title = '%s%s%s' % ((platform and '(%s) ' %... |
if isinstance(file, unicode): file = file.encode('utf-8') epub.write(path.join(outdir, file), file, zipfile.ZIP_DEFLATED) | fp = path.join(outdir, file) if isinstance(fp, unicode): fp = fp.encode(sys.getfilesystemencoding()) epub.write(fp, file, zipfile.ZIP_DEFLATED) | def build_epub(self, outdir, outname): """Write the epub file. |
if len(node) and 'std-term' in node[0].get('classes', []): | if len(node) and hasattr(node[0], 'attributes') and \ 'std-term' in node[0].get('classes', []): | def visit_reference(self, node): uri = node.get('refuri', '') if self.in_title or not uri: self.context.append('') elif uri.startswith('mailto:') or uri.startswith('http:') or \ uri.startswith('https:') or uri.startswith('ftp:'): self.body.append('\\href{%s}{' % self.encode_uri(uri)) # if configured, put the URL after ... |
env.domaindata['std']['objects'][self.name, fullname] = \ | name = self.name if ':' in self.name: _, name = self.name.split(':', 1) env.domaindata['std']['objects'][name, fullname] = \ | def run(self): env = self.state.document.settings.env # normalize whitespace in fullname like XRefRole does fullname = ws_re.sub('', self.arguments[0].strip()) targetname = '%s-%s' % (self.name, fullname) node = nodes.target('', '', ids=[targetname]) self.state.document.note_explicit_target(node) ret = [node] if self.i... |
maxindex = len(lines) | maxindex = len(lines) - 1 | def collect_pages(app): env = app.builder.env if not hasattr(env, '_viewcode_modules'): return highlighter = app.builder.highlighter urito = app.builder.get_relative_uri modnames = set(env._viewcode_modules) app.builder.info(' (%d module code pages)' % len(env._viewcode_modules), nonl=1) for modname, entry in env._v... |
docname = posixpath.splitext(posixpath.basename(source))[0] | assert source.startswith(env.srcdir) docname = posixpath.splitext(source[len(env.srcdir):].lstrip('/'))[0] | def apply(self): env = self.document.settings.env settings, source = self.document.settings, self.document['source'] # XXX check if this is reliable docname = posixpath.splitext(posixpath.basename(source))[0] section = docname.split(SEP, 1)[0] |
f = codecs.EncodedFile(open(fn, 'U'), encoding) | f = codecs.StreamReaderWriter(open(fn, 'U'), codec_info.streamreader, codec_info.streamwriter, 'strict') | def run(self): document = self.state.document filename = self.arguments[0] if not document.settings.file_insertion_enabled: return [document.reporter.warning('File insertion disabled', line=self.lineno)] env = document.settings.env if filename.startswith('/') or filename.startswith(os.sep): rel_fn = filename[1:] else: ... |
if self.docroot is not '': | if self.docroot != '': | def _make_base_comment_options(self): """Helper method to create the part of the COMMENT_OPTIONS javascript that remains the same throughout the lifetime of the :class:`~sphinx.websupport.WebSupport` object. """ self.base_comment_opts = {} |
lines[end - 1] += '</div>' | lines[min(end - 1, maxindex)] += '</div>' | def collect_pages(app): env = app.builder.env if not hasattr(env, '_viewcode_modules'): return highlighter = app.builder.highlighter urito = app.builder.get_relative_uri modnames = set(env._viewcode_modules) app.builder.info(' (%d module code pages)' % len(env._viewcode_modules), nonl=1) for modname, entry in env._v... |
def __init__(self, class_names, currmodule, show_builtins=False): | def __init__(self, class_names, currmodule, show_builtins=False, parts=0): | def __init__(self, class_names, currmodule, show_builtins=False): """ *class_names* is a list of child classes to show bases from. |
self.classes = self._import_classes(class_names, currmodule) self.all_classes = self._all_classes(self.classes) if len(self.all_classes) == 0: | classes = self._import_classes(class_names, currmodule) self.class_info = self._class_info(classes, show_builtins, parts) if not self.class_info: | def __init__(self, class_names, currmodule, show_builtins=False): """ *class_names* is a list of child classes to show bases from. |
self.show_builtins = show_builtins | def __init__(self, class_names, currmodule, show_builtins=False): """ *class_names* is a list of child classes to show bases from. | |
def _all_classes(self, classes): """ Return a list of all classes that are ancestors of *classes*. | def _class_info(self, classes, show_builtins, parts): """Return name and bases for all classes that are ancestors of *classes*. *parts* gives the number of dotted name parts that is removed from the displayed node names. | def _all_classes(self, classes): """ Return a list of all classes that are ancestors of *classes*. """ all_classes = {} |
all_classes[cls] = None for c in cls.__bases__: if c not in all_classes: recurse(c) | if not show_builtins and cls in builtins: return nodename = self.class_name(cls, parts) fullname = self.class_name(cls, 0) baselist = [] all_classes[cls] = (nodename, fullname, baselist) for base in cls.__bases__: if not show_builtins and base in builtins: return baselist.append(self.class_name(base, parts)) if base ... | def recurse(cls): all_classes[cls] = None for c in cls.__bases__: if c not in all_classes: recurse(c) |
return all_classes.keys() | return all_classes.values() | def recurse(cls): all_classes[cls] = None for c in cls.__bases__: if c not in all_classes: recurse(c) |
return [self.class_name(x) for x in self.all_classes] | return [fullname for (_, fullname, _) in self.class_info] | def get_all_class_names(self): """ Get all of the class names involved in the graph. """ return [self.class_name(x) for x in self.all_classes] |
def generate_dot(self, name, parts=0, urls={}, env=None, | def generate_dot(self, name, urls={}, env=None, | def generate_dot(self, name, parts=0, urls={}, env=None, graph_attrs={}, node_attrs={}, edge_attrs={}): """ Generate a graphviz dot graph from the classes that were passed in to __init__. |
for cls in self.all_classes: if not self.show_builtins and cls in __builtins__.values(): continue name = self.class_name(cls, parts) | for name, fullname, bases in self.class_info: | def generate_dot(self, name, parts=0, urls={}, env=None, graph_attrs={}, node_attrs={}, edge_attrs={}): """ Generate a graphviz dot graph from the classes that were passed in to __init__. |
url = urls.get(self.class_name(cls)) | url = urls.get(fullname) | def generate_dot(self, name, parts=0, urls={}, env=None, graph_attrs={}, node_attrs={}, edge_attrs={}): """ Generate a graphviz dot graph from the classes that were passed in to __init__. |
for base in cls.__bases__: if not self.show_builtins and base in __builtins__.values(): continue base_name = self.class_name(base, parts) | for base_name in bases: | def generate_dot(self, name, parts=0, urls={}, env=None, graph_attrs={}, node_attrs={}, edge_attrs={}): """ Generate a graphviz dot graph from the classes that were passed in to __init__. |
graph = InheritanceGraph(class_names, env.temp_data.get('py:module')) | graph = InheritanceGraph( class_names, env.temp_data.get('py:module'), parts=node['parts']) | def run(self): node = inheritance_diagram() node.document = self.state.document env = self.state.document.settings.env class_names = self.arguments[0].split() class_role = env.get_domain('py').role('class') |
node['parts'] = self.options.get('parts', 0) node['content'] = ', '.join(class_names) | def run(self): node = inheritance_diagram() node.document = self.state.document env = self.state.document.settings.env class_names = self.arguments[0].split() class_role = env.get_domain('py').role('class') | |
parts = node['parts'] | def html_visit_inheritance_diagram(self, node): """ Output the graph for HTML. This will insert a PNG with clickable image map. """ graph = node['graph'] parts = node['parts'] graph_hash = get_graph_hash(node) name = 'inheritance%s' % graph_hash # Create a mapping from fully-qualified class names to URLs. urls = {} ... | |
dotcode = graph.generate_dot(name, parts, urls, env=self.builder.env) | dotcode = graph.generate_dot(name, urls, env=self.builder.env) | def html_visit_inheritance_diagram(self, node): """ Output the graph for HTML. This will insert a PNG with clickable image map. """ graph = node['graph'] parts = node['parts'] graph_hash = get_graph_hash(node) name = 'inheritance%s' % graph_hash # Create a mapping from fully-qualified class names to URLs. urls = {} ... |
parts = node['parts'] | def latex_visit_inheritance_diagram(self, node): """ Output the graph for LaTeX. This will insert a PDF. """ graph = node['graph'] parts = node['parts'] graph_hash = get_graph_hash(node) name = 'inheritance%s' % graph_hash dotcode = graph.generate_dot(name, parts, env=self.builder.env, graph_attrs={'size': '"6.0,6.0... | |
dotcode = graph.generate_dot(name, parts, env=self.builder.env, | dotcode = graph.generate_dot(name, env=self.builder.env, | def latex_visit_inheritance_diagram(self, node): """ Output the graph for LaTeX. This will insert a PDF. """ graph = node['graph'] parts = node['parts'] graph_hash = get_graph_hash(node) name = 'inheritance%s' % graph_hash dotcode = graph.generate_dot(name, parts, env=self.builder.env, graph_attrs={'size': '"6.0,6.0... |
self.outdir = outdir or os.path.join(self.srcdir, '_build', 'websupport') | self.outdir = outdir or path.join(self.srcdir, '_build', 'websupport') | def init(self, srcdir, outdir='', comment_html=''): self.srcdir = srcdir self.outdir = outdir or os.path.join(self.srcdir, '_build', 'websupport') self.comment_template = Template(comment_html) |
text = utils.unescape(text) | target = utils.unescape(target) | def __call__(self, typ, rawtext, text, lineno, inliner, options={}, content=[]): env = inliner.document.settings.env if not typ: typ = env.config.default_role else: typ = typ.lower() if ':' not in typ: domain, role = '', typ classes = ['xref', role] else: domain, role = typ.split(':', 1) classes = ['xref', domain, '%s-... |
transforms = [CitationReferences, DefaultSubstitutions, | transforms = [Locale, CitationReferences, DefaultSubstitutions, | def apply(self): for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, reftype='citation', reftarget=cittext) refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode) |
section = docname.split(SEP, 1)[0] | def read_doc(self, docname, src_path=None, save_parsed=True, app=None): """ Parse a file and add/update inventory entries for the doctree. If srcpath is given, read from a different source file. """ section = docname.split(SEP, 1)[0] # remove all inventory entries for that file if app: app.emit('env-purge-doc', self, d... | |
self.process_translations(doctree, self.get_translation(section)) | def read(self_): data = FileInput.read(self_) if app: arg = [data] app.emit('source-read', docname, arg) data = arg[0] if self.config.rst_epilog: data = data + '\n' + self.config.rst_epilog + '\n' if self.config.rst_prolog: data = self.config.rst_prolog + '\n' + data return data | |
def get_translation(self, section): dirs = [path.join(self.srcdir, x) for x in self.config.locale_dirs] translation, has_trans = init_locale(dirs, self.config.language, section) if not has_trans: return None return translation | def get_translation(self, section): dirs = [path.join(self.srcdir, x) for x in self.config.locale_dirs] translation, has_trans = init_locale(dirs, self.config.language, section) if not has_trans: return None return translation | |
def process_translations(self, doctree, translation): """ Replace translatable nodes with their translated doctree. """ if not translation: return settings, source = doctree.settings, doctree['source'] parser = RSTParser() for node, msg in extract_messages(doctree): ctx = node.parent patch = new_document(source, settin... | def filter_messages(self, doctree): """ Filter system messages from a doctree. """ filterlevel = self.config.keep_warnings and 2 or 5 for node in doctree.traverse(nodes.system_message): if node['level'] < filterlevel: node.parent.remove(node) | |
class Locale(Transform): """ Replace translatable nodes with their translated doctree. """ default_priority = 0 def apply(self): settings, source = self.document.settings, self.document['source'] parser = RSTParser() for node, msg in extract_messages(self.document): ctx = node.parent patch = new_document(source, setti... | def apply(self): for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, reftype='citation', reftarget=cittext) refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode) | |
transforms = [Locale, CitationReferences, DefaultSubstitutions, | transforms = [CitationReferences, DefaultSubstitutions, | def apply(self): settings, source = self.document.settings, self.document['source'] parser = RSTParser() for node, msg in extract_messages(self.document): ctx = node.parent patch = new_document(source, settings) msgstr = "Insert translation **here**." parser.parse(msgstr, patch) ctx.replace(node, patch.children) |
print self.objtype, name | def add_target_and_index(self, name, sig, signode): if name not in self.state.document.ids: signode['names'].append(name) signode['ids'].append(name) signode['first'] = (not self.names) self.state.document.note_explicit_target(signode) objects = self.env.domaindata['rst']['objects'] #XXX add warning for duplicate defi... | |
or cache[uri][0] < cache_time: | or cache[uri][1] < cache_time: | def load_mappings(app): """Load all intersphinx mappings into the environment.""" now = int(time.time()) cache_time = now - app.config.intersphinx_cache_limit * 86400 env = app.builder.env if not hasattr(env, 'intersphinx_cache'): env.intersphinx_cache = {} cache = env.intersphinx_cache update = False for key, value in... |
for old_node, new_node in izip_longest(old_iter, new_iter): | for old_node, new_node in zip_longest(old_iter, new_iter): | def merge_doctrees(old, new, condition): """ Merges the `old` doctree with the `new` one while looking at nodes matching the `condition`. Each node which replaces another one or has been added to the `new` doctree will be yielded. :param condition: A callable which returns either ``True`` or ``False`` for a given nod... |
'<p><em( class="xref std-option")?>--with-option</em></p>$', | '<p><em( class="xref std std-option")?>--with-option</em></p>$', | def test_inline(): # correct interpretation of code with whitespace _html = ('<p><tt class="(samp )?docutils literal"><span class="pre">' 'code</span> <span class="pre">sample</span></tt></p>') yield verify_re, '``code sample``', _html, r'\\code{code sample}' yield verify_re, ':samp:`code sample`', _h... |
if not id.startswith('index-'): self.body.append(self.hypertarget(id)) | if id.startswith('index-'): return anchor = not self.in_title self.body.append(self.hypertarget(id, anchor=anchor)) | def add_target(id): # indexing uses standard LaTeX index markup, so the targets # will be generated differently if not id.startswith('index-'): self.body.append(self.hypertarget(id)) |
return time.strftime(unicode(format).encode('utf-8'), *args).decode('utf-8') | return time.strftime(unicode(format).encode('utf-8'), *args) \ .decode('utf-8') | def ustrftime(format, *args): # strftime for unicode strings return time.strftime(unicode(format).encode('utf-8'), *args).decode('utf-8') |
f.write(item.encode('ascii', 'xmlcharrefreplace')) | f.write(item.encode(self.encoding, 'xmlcharrefreplace')) | def write_param(name, value): item = ' <param name="%s" value="%s">\n' % (name, value) f.write(item.encode('ascii', 'xmlcharrefreplace')) |
def get_sidebars(self, pagename): | def add_sidebars(self, pagename, ctx): | def get_sidebars(self, pagename): def has_wildcard(pattern): return any(char in pattern for char in '*?[') sidebars = None matched = None for pattern, patsidebars in self.config.html_sidebars.iteritems(): if patmatch(pagename, pattern): if matched: if has_wildcard(pattern): # warn if both patterns contain wildcards if ... |
sidebars = self.default_sidebars | pass | def has_wildcard(pattern): return any(char in pattern for char in '*?[') |
sidebars = self.default_sidebars[:-1] + [sidebars] + \ self.default_sidebars[-1:] return sidebars | customsidebar = sidebars sidebars = None ctx['sidebars'] = sidebars ctx['customsidebar'] = customsidebar | def has_wildcard(pattern): return any(char in pattern for char in '*?[') |
ctx['sidebars'] = self.get_sidebars(pagename) | self.add_sidebars(pagename, ctx) | def pathto(otheruri, resource=False, baseuri=self.get_target_uri(pagename)): if not resource: otheruri = self.get_target_uri(otheruri) uri = relative_uri(baseuri, otheruri) or '#' return uri |
ctx['sidebars'] = self.get_sidebars(pagename) | self.add_sidebars(pagename, ctx) | def handle_page(self, pagename, ctx, templatename='page.html', outfilename=None, event_arg=None): ctx['current_page_name'] = pagename ctx['sidebars'] = self.get_sidebars(pagename) |
def _is_only_paragraph(node): | def _is_single_paragraph(node): | def _is_only_paragraph(node): """True if the node only contains one paragraph (and system messages).""" if len(node) == 0: return False elif len(node) > 1: for subnode in node[1:]: if not isinstance(subnode, nodes.system_message): return False if isinstance(node[0], nodes.paragraph): return True return False |
typename = types[fieldarg] if isinstance(typename, list): typename = u''.join(n.astext() for n in typename) | typename = u''.join(n.astext() for n in types[fieldarg]) | def make_field(self, types, domain, items): fieldname = nodes.field_name('', self.label) listnode = self.list_type() for fieldarg, content in items: par = nodes.paragraph() par += self.make_xref(self.rolename, domain, fieldarg, nodes.strong) if fieldarg in types: typename = types[fieldarg] if isinstance(typename, list)... |
typemap[name] = fieldtype, 0 | typemap[name] = fieldtype, False | def preprocess_fieldtypes(self, types): typemap = {} for fieldtype in types: for name in fieldtype.names: typemap[name] = fieldtype, 0 if fieldtype.is_typed: for name in fieldtype.typenames: typemap[name] = fieldtype, 1 return typemap |
typemap[name] = fieldtype, 1 | typemap[name] = fieldtype, True | def preprocess_fieldtypes(self, types): typemap = {} for fieldtype in types: for name in fieldtype.names: typemap[name] = fieldtype, 0 if fieldtype.is_typed: for name in fieldtype.typenames: typemap[name] = fieldtype, 1 return typemap |
if typedesc is None or \ typedesc.has_arg != bool(fieldarg): | typename = typedesc.name if typedesc is None or typedesc.has_arg != bool(fieldarg): | def transform(self, node): """Transform a single field list *node*.""" typemap = self.typemap |
typename = typedesc.name if _is_only_paragraph(fieldbody): | if _is_single_paragraph(fieldbody): | def transform(self, node): """Transform a single field list *node*.""" typemap = self.typemap |
types.setdefault(typename, {})[fieldarg] = content | content = filter(lambda n: isinstance(n, nodes.Inline), content) if content: types.setdefault(typename, {})[fieldarg] = content | def transform(self, node): """Transform a single field list *node*.""" typemap = self.typemap |
try: argtype, argname = fieldarg.split(None, 1) except ValueError: pass else: types.setdefault(typename, {})[argname] = nodes.Text(argtype) fieldarg = argname | if typedesc.is_typed: try: argtype, argname = fieldarg.split(None, 1) except ValueError: pass else: types.setdefault(typename, {})[argname] = \ [nodes.Text(argtype)] fieldarg = argname | def transform(self, node): """Transform a single field list *node*.""" typemap = self.typemap |
jsfile = path.join(package_dir, 'locale', self.config.language, 'LC_MESSAGES', 'sphinx.js') if path.isfile(jsfile): self.script_files.append('_static/translations.js') | jsfile_list = [path.join(package_dir, 'locale', self.config.language, 'LC_MESSAGES', 'sphinx.js'), path.join(sys.prefix, 'share/sphinx/locale', self.config.language, 'sphinx.js')] for jsfile in jsfile_list: if path.isfile(jsfile): self.script_files.append('_static/translations.js') break | def init(self): # a hash of all config values that, if changed, cause a full rebuild self.config_hash = '' self.tags_hash = '' # section numbers for headings in the currently visited document self.secnumbers = {} |
jsfile = path.join(package_dir, 'locale', self.config.language, 'LC_MESSAGES', 'sphinx.js') if path.isfile(jsfile): copyfile(jsfile, path.join(self.outdir, '_static', 'translations.js')) | jsfile_list = [path.join(package_dir, 'locale', self.config.language, 'LC_MESSAGES', 'sphinx.js'), path.join(sys.prefix, 'share/sphinx/locale', self.config.language, 'sphinx.js')] for jsfile in jsfile_list: if path.isfile(jsfile): copyfile(jsfile, path.join(self.outdir, '_static', 'translations.js')) break | def sorthelper(entry): name = entry[0] if name == '': # heading name = entry[4] return name.lower() |
% (self.config.project, self.config.version))\ .encode('utf-8')) | % (self.config.project, self.config.version) ).encode('utf-8')) | def dump_inventory(self): self.info(bold('dumping object inventory... '), nonl=True) f = open(path.join(self.outdir, INVENTORY_FILENAME), 'wb') try: f.write((u'# Sphinx inventory version 2\n' u'# Project: %s\n' u'# Version: %s\n' u'# The remainder of this file is compressed using zlib.\n' % (self.config.project, self.c... |
(u'%s %s:%s %s %s %s\n' % (name, domainname, type, prio, uri, dispname))\ .encode('utf-8'))) | (u'%s %s:%s %s %s %s\n' % (name, domainname, type, prio, uri, dispname) ).encode('utf-8'))) | def dump_inventory(self): self.info(bold('dumping object inventory... '), nonl=True) f = open(path.join(self.outdir, INVENTORY_FILENAME), 'wb') try: f.write((u'# Sphinx inventory version 2\n' u'# Project: %s\n' u'# Version: %s\n' u'# The remainder of this file is compressed using zlib.\n' % (self.config.project, self.c... |
io = StringIO.StringIO() | string_io = StringIO.StringIO() | def summarize(self, out, verbose=None): io = StringIO.StringIO() old_stdout = sys.stdout sys.stdout = io try: res = doctest.DocTestRunner.summarize(self, verbose) finally: sys.stdout = old_stdout out(io.getvalue()) return res |
sys.stdout = io | sys.stdout = string_io | def summarize(self, out, verbose=None): io = StringIO.StringIO() old_stdout = sys.stdout sys.stdout = io try: res = doctest.DocTestRunner.summarize(self, verbose) finally: sys.stdout = old_stdout out(io.getvalue()) return res |
out(io.getvalue()) | out(string_io.getvalue()) | def summarize(self, out, verbose=None): io = StringIO.StringIO() old_stdout = sys.stdout sys.stdout = io try: res = doctest.DocTestRunner.summarize(self, verbose) finally: sys.stdout = old_stdout out(io.getvalue()) return res |
msg = node.astext().replace('\n', ' ') | msg = node.astext().replace('\n', ' ').strip() if not msg or msg in catalog: continue | def write_doc(self, docname, doctree): """ Store a document's translatable strings in the message catalog of its section. For this purpose a document's *top-level directory* -- or otherwise its *name* -- is considered its section. """ catalog = self.catalogs[docname.split('/')[0]] for node in doctree.traverse(nodes.Tex... |
transforms = [CitationReferences, DefaultSubstitutions, MoveModuleTargets, HandleCodeBlocks, SortIds] | transforms = [Locale, CitationReferences, DefaultSubstitutions, MoveModuleTargets, HandleCodeBlocks, SortIds] | def apply(self): for citnode in self.document.traverse(nodes.citation_reference): cittext = citnode.astext() refnode = addnodes.pending_xref(cittext, reftype='citation', reftarget=cittext) refnode += nodes.Text('[' + cittext + ']') citnode.parent.replace(citnode, refnode) |
while lineno is None and node: | while lineno is None: | def check(self, node, docname): uri = node['refuri'] |
for index in self.domain_indices: f.write('<LI> ' + object_sitemap % (index[2], '%s-%s.html' % index[0:2])) | for indexname, indexcls, content, collapse in self.domain_indices: f.write('<LI> ' + object_sitemap % (indexcls.localname, '%s.html' % indexname)) | def build_hhx(self, outdir, outname): self.info('dumping stopword list...') f = self.open_file(outdir, outname+'.stp') try: for word in sorted(stopwords): print >>f, word finally: f.close() |
fname, outfn = render_dot(self, code, options, 'pnf', prefix) | fname, outfn = render_dot(self, code, options, 'png', prefix) | def render_dot_html(self, node, code, options, prefix='graphviz', imgcls=None, alt=None): try: fname, outfn = render_dot(self, code, options, 'pnf', prefix) except GraphvizError, exc: self.builder.warn('dot code %r: ' % code + str(exc)) raise nodes.SkipNode self.body.append(self.starttag(node, 'p', CLASS='graphviz')) ... |
sys.stderr, darkred('reST markup error:') | print >>sys.stderr, darkred('reST markup error:') | def run(self): if not color_terminal(): # Windows' poor cmd box doesn't understand ANSI sequences nocolor() if not self.verbose: status_stream = StringIO() else: status_stream = sys.stdout confoverrides = {} if self.version: confoverrides['version'] = self.version if self.release: confoverrides['release'] = self.releas... |
return translator.gettext(message) | return translator.ugettext(message) | def _(message): return translator.gettext(message) |
self.temp_data['docname'] = docname self.temp_data['default_domain'] = \ self.domains.get(self.config.default_domain) self.settings['input_encoding'] = self.config.source_encoding self.settings['trim_footnote_reference_space'] = \ self.config.trim_footnote_reference_space self.patch_lookup_functions() | def read_doc(self, docname, src_path=None, save_parsed=True, app=None): """ Parse a file and add/update inventory entries for the doctree. If srcpath is given, read from a different source file. """ # remove all inventory entries for that file if app: app.emit('env-purge-doc', self, docname) | |
for fp in self.walk_doctree_files(self): | for fp in self.walk_doctree_files(): | def init(self): for fp in self.walk_doctree_files(self): if fp.endswith('.doctree'): copyfile(fp, fp + '.old') |
if name not in self.state.document.ids: targetname = name + '-' + self.objtype | targetname = name + '-' + self.objtype if targetname not in self.state.document.ids: | def add_target_and_index(self, name, sig, signode): if name not in self.state.document.ids: targetname = name + '-' + self.objtype signode['names'].append(targetname) signode['ids'].append(targetname) signode['first'] = (not self.names) self.state.document.note_explicit_target(signode) |
``True`` if the `new` string differs from the `old` one with at least one character. | ``True`` if the `new` string is a changed version of the `old` one. | def make_diff(old, new): """ Takes two strings `old` and `new` and returns a :class:`tuple` of boolean values ``(equals, changed, replaced)``. equals ``True`` if the `old` string and the `new` one are equal. changed ``True`` if the `new` string differs from the `old` one with at least one character. replaced ``Tr... |
self.context.append('\\end{wrapfigure}\n') | self.context.append(ids + '\\end{wrapfigure}\n') | def visit_figure(self, node): if node.has_key('width') and node.get('align', '') in ('left', 'right'): self.body.append('\\begin{wrapfigure}{%s}{%s}\n\\centering' % (node['align'] == 'right' and 'r' or 'l', node['width'])) self.context.append('\\end{wrapfigure}\n') else: if (not node.attributes.has_key('align') or node... |
self.context.append('%s\\end{figure}\n' % align_end) | self.context.append(ids + align_end + '\\end{figure}\n') | def visit_figure(self, node): if node.has_key('width') and node.get('align', '') in ('left', 'right'): self.body.append('\\begin{wrapfigure}{%s}{%s}\n\\centering' % (node['align'] == 'right' and 'r' or 'l', node['width'])) self.context.append('\\end{wrapfigure}\n') else: if (not node.attributes.has_key('align') or node... |
return name.replace('/', '_') | return name.replace('/', '_').replace(' ', '') | def make_id(self, name): """Replace all characters not allowed for (X)HTML ids.""" return name.replace('/', '_') |
translation, has_trans = init_locale(self.config.locale_dirs, | dirs = [path.join(self.srcdir, x) for x in self.config.locale_dirs] translation, has_trans = init_locale(dirs, | def get_translation(self, section): translation, has_trans = init_locale(self.config.locale_dirs, self.config.language, section) if not has_trans: return None return translation |
msgstr = translation.gettext(msg) | msgstr = translation.ugettext(msg) | def process_translations(self, doctree, translation): """ Replace translatable nodes with their translated doctree. """ if not translation: return settings, source = doctree.settings, doctree['source'] parser = RSTParser() for node, msg in extract_messages(doctree): ctx = node.parent patch = new_document(source, settin... |
pathto('_static/pygment.css', 1) | pathto('_static/pygments.css', 1) | def pathto(otheruri, resource=False, baseuri=self.get_target_uri(pagename)): if not resource: otheruri = self.get_target_uri(otheruri) return relative_uri(baseuri, otheruri) or '#' else: return '/' + posixpath.join(self.app.staticdir, otheruri) |
pathto('_static/pygmentcs.css', 1) | pathto('_static/pygment.css', 1) | def pathto(otheruri, resource=False, baseuri=self.get_target_uri(pagename)): if not resource: otheruri = self.get_target_uri(otheruri) return relative_uri(baseuri, otheruri) or '#' else: return '/' + posixpath.join(self.app.staticdir, otheruri) |
from sphinx.writers.manpage import ManualPageTranslator as translator | from sphinx.writers.manpage import ManualPageTranslator \ as translator | def add_node(self, node, **kwds): nodes._add_node_class_names([node.__name__]) for key, val in kwds.iteritems(): try: visit, depart = val except ValueError: raise ExtensionError('Value for key %r must be a ' '(visit, depart) function tuple' % key) if key == 'html': from sphinx.writers.html import HTMLTranslator as tran... |
if node.get('internal'): | if node.get('internal') or 'refuri' not in node: | def visit_reference(self, node): atts = {'class': 'reference'} if node.get('internal'): atts['class'] += ' internal' else: atts['class'] += ' external' if 'refuri' in node: atts['href'] = node['refuri'] if self.settings.cloak_email_addresses and \ atts['href'].startswith('mailto:'): atts['href'] = self.cloak_mailto(att... |
fieldbody = nodes.field_body('', nodes.paragraph('', *content)) | fieldbody = nodes.field_body('', nodes.paragraph('', '', *content)) | def make_field(self, types, domain, item): fieldarg, content = item fieldname = nodes.field_name('', self.label) if fieldarg: fieldname += nodes.Text(' ') fieldname += self.make_xref(self.rolename, domain, fieldarg, nodes.Text) fieldbody = nodes.field_body('', nodes.paragraph('', *content)) return nodes.field('', field... |
def _parse_type_expr(self): typename = self._parse_name() self.skip_ws() if not self.skip_string('<'): return typename args = [] while 1: self.skip_ws() if self.skip_string('>'): break if args: if not self.skip_string(','): self.fail('"," or ">" in template expected') self.skip_ws() args.append(self._parse_type(True))... | def _parse_type_expr(self): typename = self._parse_name() self.skip_ws() if not self.skip_string('<'): return typename | |
rv = ModifierDefExpr(modifiers, _NameDefExpr(typename)) | rv = ModifierDefExpr(modifiers, NameDefExpr(typename)) | def _parse_builtin(self, modifier): path = [modifier] following = self._modifiers[modifier] while 1: self.skip_ws() if not self.match(_identifier_re): break identifier = self.matched_text if identifier in following: path.append(identifier) following = self._modifiers[modifier] assert following else: self.backout() brea... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.