def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle(self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception as err: if type(err) is IOError and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn)
def read_process(docs): # type: (List[unicode]) -> unicode self.env.app = self.app for docname in docs: self.read_doc(docname) # allow pickling self to send it back return BuildEnvironment.dumps(self.env)
def _init_env(self, freshenv): # type: (bool) -> None filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if freshenv or not os.path.exists(filename): self.env = BuildEnvironment(self) self.env.find_files(self.config, self.builder) for domain in self.registry.create_domains(self.env): self.env.domains[domain.name] = domain else: try: logger.info(bold(__('loading pickled environment... ')), nonl=True) self.env = BuildEnvironment.frompickle(filename, self) needed, reason = self.env.need_refresh(self) if needed: raise IOError(reason) self.env.domains = {} for domain in self.registry.create_domains(self.env): # this can raise if the data version doesn't fit self.env.domains[domain.name] = domain logger.info(__('done')) except Exception as err: logger.info(__('failed: %s'), err) self._init_env(freshenv=True)
def _init_env(self, freshenv): # type: (bool) -> None if freshenv: self.env = BuildEnvironment(self) self.env.find_files(self.config, self.builder) for domain in self.registry.create_domains(self.env): self.env.domains[domain.name] = domain else: try: logger.info(bold(__('loading pickled environment... ')), nonl=True) filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) self.env = BuildEnvironment.frompickle(filename, self) self.env.domains = {} for domain in self.registry.create_domains(self.env): # this can raise if the data version doesn't fit self.env.domains[domain.name] = domain logger.info(__('done')) except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: logger.info(__('not yet created')) else: logger.info(__('failed: %s'), err) self._init_env(freshenv=True)
def _init_env(self, freshenv): # type: (bool) -> None filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if freshenv or not os.path.exists(filename): self.env = BuildEnvironment() self.env.setup(self) self.env.find_files(self.config, self.builder) else: try: with progress_message(__('loading pickled environment')): with open(filename, 'rb') as f: self.env = pickle.load(f) self.env.setup(self) except Exception as err: logger.info(__('failed: %s'), err) self._init_env(freshenv=True)
def get_sphinx_environment(self): """ Returns the Sphinx environment for this project. """ from sphinx.environment import BuildEnvironment class Foo(object): pass config = Foo() config.values = [] env_pickle = os.path.join(self._doctrees_dir(), 'environment.pickle') try: env = BuildEnvironment.frompickle(config, env_pickle) logger.debug("Opened Sphinx environment: %s", env_pickle) return env except IOError as err: logger.debug("Failed to open Sphinx environment: %s", err) pass
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): # type: (unicode, unicode, unicode, unicode, unicode, Dict, IO, IO, bool, bool, unicode, int, int) -> None # NOQA self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} # type: Dict[unicode, Any] self._extension_metadata = {} # type: Dict[unicode, Dict[unicode, Any]] self._additional_source_parsers = {} # type: Dict[unicode, Parser] self._listeners = {} # type: Dict[unicode, Dict[int, Callable]] self._setting_up_extension = ['?'] # type: List[unicode] self.domains = {} # type: Dict[unicode, Type[Domain]] self.buildername = buildername self.builderclasses = {} # type: Dict[unicode, Type[Builder]] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.enumerable_nodes = {} # type: Dict[nodes.Node, Tuple[unicode, Callable]] # NOQA self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() # type: IO else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() self._translators = {} # type: Dict[unicode, nodes.GenericNodeVisitor] # keep last few messages for traceback self.messagelog = deque(maxlen=10) # type: deque # say hello to the world self.info(bold('Running Sphinx v%s' % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): self.info('making output directory...') os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # defer checking types until i18n has been initialized # initialize some limited config variables before loading extensions self.config.pre_init_values(self.warn) # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( 'This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.' % self.config.needs_sphinx) # force preload html_translator_class if self.config.html_translator_class: translator_class = self.import_object(self.config.html_translator_class, 'html_translator_class setting') self.set_translator('html', translator_class) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # extension loading support for alabaster theme # self.config.html_theme is not set from conf.py at here # for now, sphinx always load a 'alabaster' extension. if 'alabaster' not in self.config.extensions: self.config.extensions.append('alabaster') # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: self._setting_up_extension = ['conf.py'] # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, '__call__'): self.config.setup(self) else: raise ConfigError( "'setup' that is specified in the conf.py has not been " + "callable. Please provide a callable `setup` function " + "in order to behave as a sphinx extension conf.py itself." ) # now that we know all config values, collect them from conf.py self.config.init_values(self.warn) # check extension versions if requested if self.config.needs_extensions: for extname, needs_ver in self.config.needs_extensions.items(): if extname not in self._extensions: self.warn('needs_extensions config value specifies a ' 'version requirement for extension %s, but it is ' 'not loaded' % extname) continue has_ver = self._extension_metadata[extname]['version'] if has_ver == 'unknown version' or needs_ver > has_ver: raise VersionRequirementError( 'This project needs the extension %s at least in ' 'version %s and therefore cannot be built with the ' 'loaded version (%s).' % (extname, needs_ver, has_ver)) # check primary_domain if requested if self.config.primary_domain and self.config.primary_domain not in self.domains: self.warn('primary_domain %r not found, ignored.' % self.config.primary_domain) # set up translation infrastructure self._init_i18n() # check all configuration values for permissible types self.config.check_types(self.warn) # set up source_parsers self._init_source_parsers() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(self.buildername) # set up the enumerable nodes self._init_enumerable_nodes() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) user_locale_dirs = [ path.join(self.srcdir, x) for x in self.config.locale_dirs] # compile mo files if sphinx.po file in user locale directories are updated for catinfo in find_catalog_source_files( user_locale_dirs, self.config.language, domains=['sphinx'], charset=self.config.source_encoding): catinfo.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale')] + user_locale_dirs else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated self.info('done') else: self.info('not available for built-in messages') def _init_source_parsers(self): # type: () -> None for suffix, parser in iteritems(self._additional_source_parsers): if suffix not in self.config.source_suffix: self.config.source_suffix.append(suffix) if suffix not in self.config.source_parsers: self.config.source_parsers[suffix] = parser def _init_env(self, freshenv): # type: (bool) -> None if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.set_warnfunc(self.warn) self.env.find_files(self.config, self.buildername) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle( self.srcdir, self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.set_warnfunc(self.warn) self.env.init_managers() self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) self._init_env(freshenv=True) def _init_builder(self, buildername): # type: (unicode) -> None if buildername is None: print('No builder selected, using default: html', file=self._status) buildername = 'html' if buildername not in self.builderclasses: raise SphinxError('Builder name %s not registered' % buildername) builderclass = self.builderclasses[buildername] self.builder = builderclass(self) self.emit('builder-inited') def _init_enumerable_nodes(self): # type: () -> None for node, settings in iteritems(self.enumerable_nodes): self.env.get_domain('std').enumerable_nodes[node] = settings # type: ignore # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[unicode]) -> None try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = (self.statuscode == 0 and 'succeeded' or 'finished with problems') if self._warncount: self.info(bold('build %s, %s warning%s.' % (status, self._warncount, self._warncount != 1 and 's' or ''))) else: self.info(bold('build %s.' % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def _log(self, message, wfile, nonl=False): # type: (unicode, IO, bool) -> None try: wfile.write(message) except UnicodeEncodeError: encoding = getattr(wfile, 'encoding', 'ascii') or 'ascii' # wfile.write accept only str, not bytes.So, we encode and replace # non-encodable characters, then decode them. wfile.write(message.encode(encoding, 'replace').decode(encoding)) if not nonl: wfile.write('\n') if hasattr(wfile, 'flush'): wfile.flush() self.messagelog.append(message) def warn(self, message, location=None, prefix='WARNING: ', type=None, subtype=None, colorfunc=darkred): # type: (unicode, unicode, unicode, unicode, unicode, Callable) -> None """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. *type* and *subtype* are used to suppress warnings with :confval:`suppress_warnings`. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if is_suppressed_warning(type, subtype, self.config.suppress_warnings): return if isinstance(location, tuple): docname, lineno = location if docname: location = '%s:%s' % (self.env.doc2path(docname), lineno or '') else: location = None warntext = location and '%s: %s%s\n' % (location, prefix, message) or \ '%s%s\n' % (prefix, message) if self.warningiserror: raise SphinxWarning(warntext) self._warncount += 1 self._log(colorfunc(warntext), self._warning, True) def info(self, message='', nonl=False): # type: (unicode, bool) -> None """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ self._log(message, self._status, nonl) def verbose(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a verbose informational message. The message will only be emitted for verbosity levels >= 1 (i.e. at least one ``-v`` option was given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 1: return if args or kwargs: message = message % (args or kwargs) self._log(message, self._status) def debug(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a debug-level informational message. The message will only be emitted for verbosity levels >= 2 (i.e. at least two ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 2: return if args or kwargs: message = message % (args or kwargs) self._log(darkgray(message), self._status) def debug2(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a lowlevel debug-level informational message. The message will only be emitted for verbosity level 3 (i.e. three ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 3: return if args or kwargs: message = message % (args or kwargs) self._log(lightgray(message), self._status) def _display_chunk(chunk): # type: (Any) -> unicode if isinstance(chunk, (list, tuple)): if len(chunk) == 1: return text_type(chunk[0]) return '%s .. %s' % (chunk[0], chunk[-1]) return text_type(chunk) def old_status_iterator(self, iterable, summary, colorfunc=darkgreen, stringify_func=_display_chunk): # type: (Iterable, unicode, Callable, Callable) -> Iterator l = 0 for item in iterable: if l == 0: self.info(bold(summary), nonl=True) l = 1 self.info(colorfunc(stringify_func(item)) + ' ', nonl=True) yield item if l == 1: self.info() # new version with progress info def status_iterator(self, iterable, summary, colorfunc=darkgreen, length=0, stringify_func=_display_chunk): # type: (Iterable, unicode, Callable, int, Callable) -> Iterable if length == 0: for item in self.old_status_iterator(iterable, summary, colorfunc, stringify_func): yield item return l = 0 summary = bold(summary) for item in iterable: l += 1 s = '%s[%3d%%] %s' % (summary, 100*l/length, colorfunc(stringify_func(item))) if self.verbosity: s += '\n' else: s = term_width_line(s) self.info(s, nonl=True) yield item if l > 0: self.info() # ---- general extensibility interface ------------------------------------- def setup_extension(self, extension): # type: (unicode) -> None """Import and setup a Sphinx extension module. No-op if called twice.""" self.debug('[app] setting up extension: %r', extension) if extension in self._extensions: return if extension in EXTENSION_BLACKLIST: self.warn('the extension %r was already merged with Sphinx since version %s; ' 'this extension is ignored.' % ( extension, EXTENSION_BLACKLIST[extension])) return self._setting_up_extension.append(extension) try: mod = __import__(extension, None, None, ['setup']) except ImportError as err: self.verbose('Original exception:\n' + traceback.format_exc()) raise ExtensionError('Could not import extension %s' % extension, err) if not hasattr(mod, 'setup'): self.warn('extension %r has no setup() function; is it really ' 'a Sphinx extension module?' % extension) ext_meta = None else: try: ext_meta = mod.setup(self) except VersionRequirementError as err: # add the extension name to the version required raise VersionRequirementError( 'The %s extension used by this project needs at least ' 'Sphinx v%s; it therefore cannot be built with this ' 'version.' % (extension, err)) if ext_meta is None: ext_meta = {} # special-case for compatibility if extension == 'rst2pdf.pdfbuilder': ext_meta = {'parallel_read_safe': True} try: if not ext_meta.get('version'): ext_meta['version'] = 'unknown version' except Exception: self.warn('extension %r returned an unsupported object from ' 'its setup() function; it should return None or a ' 'metadata dictionary' % extension) ext_meta = {'version': 'unknown version'} self._extensions[extension] = mod self._extension_metadata[extension] = ext_meta self._setting_up_extension.pop() def require_sphinx(self, version): # type: (unicode) -> None # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): # type: (str, unicode) -> Any """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def _validate_event(self, event): # type: (unicode) -> None if event not in self._events: raise ExtensionError('Unknown event name: %s' % event) def connect(self, event, callback): # type: (unicode, Callable) -> int self._validate_event(event) listener_id = self.next_listener_id if event not in self._listeners: self._listeners[event] = {listener_id: callback} else: self._listeners[event][listener_id] = callback self.next_listener_id += 1 self.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None self.debug('[app] disconnecting event: [id=%s]', listener_id) for event in itervalues(self._listeners): event.pop(listener_id, None) def emit(self, event, *args): # type: (unicode, Any) -> List try: self.debug2('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass results = [] if event in self._listeners: for _, callback in iteritems(self._listeners[event]): results.append(callback(self, *args)) return results def emit_firstresult(self, event, *args): # type: (unicode, Any) -> Any for result in self.emit(event, *args): if result is not None: return result return None # registering addon parts def add_builder(self, builder): # type: (Type[Builder]) -> None self.debug('[app] adding builder: %r', builder) if not hasattr(builder, 'name'): raise ExtensionError('Builder class %s has no "name" attribute' % builder) if builder.name in self.builderclasses: raise ExtensionError( 'Builder %r already exists (in module %s)' % ( builder.name, self.builderclasses[builder.name].__module__)) self.builderclasses[builder.name] = builder def add_config_value(self, name, default, rebuild, types=()): # type: (unicode, Any, Union[bool, unicode], Any) -> None self.debug('[app] adding config value: %r', (name, default, rebuild) + ((types,) if types else ())) # type: ignore if name in self.config.values: raise ExtensionError('Config value %r already present' % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.values[name] = (default, rebuild, types) def add_event(self, name): # type: (unicode) -> None self.debug('[app] adding event: %r', name) if name in self._events: raise ExtensionError('Event %r already present' % name) self._events[name] = '' def set_translator(self, name, translator_class): # type: (unicode, Any) -> None self.info(bold('A Translator for the %s builder is changed.' % name)) self._translators[name] = translator_class def add_node(self, node, **kwds): # type: (nodes.Node, Any) -> None self.debug('[app] adding node: %r', (node, kwds)) if not kwds.pop('override', False) and \ hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__): self.warn('while setting up extension %s: node class %r is ' 'already registered, its visitors will be overridden' % (self._setting_up_extension, node.__name__), type='app', subtype='add_node') nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError('Value for key %r must be a ' '(visit, depart) function tuple' % key) translator = self._translators.get(key) if translator is not None: pass elif key == 'html': from sphinx.writers.html import HTMLTranslator as translator # type: ignore elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator as translator # type: ignore elif key == 'text': from sphinx.writers.text import TextTranslator as translator # type: ignore elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator as translator # type: ignore # NOQA elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator as translator # type: ignore # NOQA else: # ignore invalid keys for compatibility continue setattr(translator, 'visit_'+node.__name__, visit) if depart: setattr(translator, 'depart_'+node.__name__, depart) def add_enumerable_node(self, node, figtype, title_getter=None, **kwds): # type: (nodes.Node, unicode, Callable, Any) -> None self.enumerable_nodes[node] = (figtype, title_getter) self.add_node(node, **kwds) def _directive_helper(self, obj, content=None, arguments=None, **options): # type: (Any, unicode, Any, Any) -> Any if isinstance(obj, (types.FunctionType, types.MethodType)): obj.content = content # type: ignore obj.arguments = arguments or (0, 0, False) # type: ignore obj.options = options # type: ignore return convert_directive_function(obj) else: if content or arguments or options: raise ExtensionError('when adding directive classes, no ' 'additional arguments may be given') return obj def add_directive(self, name, obj, content=None, arguments=None, **options): # type: (unicode, Any, unicode, Any, Any) -> None self.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) if name in directives._directives: self.warn('while setting up extension %s: directive %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], name), type='app', subtype='add_directive') directives.register_directive( name, self._directive_helper(obj, content, arguments, **options)) def add_role(self, name, role): # type: (unicode, Any) -> None self.debug('[app] adding role: %r', (name, role)) if name in roles._roles: self.warn('while setting up extension %s: role %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], name), type='app', subtype='add_role') roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # type: (unicode, Any) -> None # don't use roles.register_generic_role because it uses # register_canonical_role self.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: self.warn('while setting up extension %s: role %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], name), type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): # type: (Type[Domain]) -> None self.debug('[app] adding domain: %r', domain) if domain.name in self.domains: raise ExtensionError('domain %s already registered' % domain.name) self.domains[domain.name] = domain def override_domain(self, domain): # type: (Type[Domain]) -> None self.debug('[app] overriding domain: %r', domain) if domain.name not in self.domains: raise ExtensionError('domain %s not yet registered' % domain.name) if not issubclass(domain, self.domains[domain.name]): raise ExtensionError('new domain not a subclass of registered %s ' 'domain' % domain.name) self.domains[domain.name] = domain def add_directive_to_domain(self, domain, name, obj, content=None, arguments=None, **options): # type: (unicode, unicode, Any, unicode, Any, Any) -> None self.debug('[app] adding directive to domain: %r', (domain, name, obj, content, arguments, options)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].directives[name] = \ self._directive_helper(obj, content, arguments, **options) def add_role_to_domain(self, domain, name, role): # type: (unicode, unicode, Any) -> None self.debug('[app] adding role to domain: %r', (domain, name, role)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].roles[name] = role def add_index_to_domain(self, domain, index): # type: (unicode, unicode) -> None self.debug('[app] adding index to domain: %r', (domain, index)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].indices.append(index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None self.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of GenericObject as the new directive new_directive = type(directivename, (GenericObject, object), # type: ignore {'indextemplate': indextemplate, 'parse_node': staticmethod(parse_node), # type: ignore 'doc_field_types': doc_field_types}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) # backwards compatible alias add_description_unit = add_object_type def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): # type: (unicode, unicode, unicode, nodes.Node, unicode) -> None self.debug('[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of Target as the new directive new_directive = type(directivename, (Target, object), # type: ignore {'indextemplate': indextemplate}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) def add_transform(self, transform): # type: (Transform) -> None self.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_javascript(self, filename): # type: (unicode) -> None self.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename): # type: (unicode) -> None self.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.css_files.append(filename) else: StandaloneHTMLBuilder.css_files.append( posixpath.join('_static', filename)) def add_latex_package(self, packagename, options=None): # type: (unicode, unicode) -> None self.debug('[app] adding latex package: %r', packagename) self.builder.usepackages.append((packagename, options)) def add_lexer(self, alias, lexer): # type: (unicode, Any) -> None self.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): # type: (Any) -> None self.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): # type: (Any, Callable) -> None self.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): # type: (Any) -> None self.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_parser(self, suffix, parser): # type: (unicode, Parser) -> None self.debug('[app] adding search source_parser: %r, %r', suffix, parser) if suffix in self._additional_source_parsers: self.warn('while setting up extension %s: source_parser for %r is ' 'already registered, it will be overridden' % (self._setting_up_extension[-1], suffix), type='app', subtype='add_source_parser') self._additional_source_parsers[suffix] = parser
def rst2html(s, fLOG=noLOG, writer="sphinx", keep_warnings=False, directives=None, language="en", warnings_log=False, **options): """ converts a string into HTML format @param s string to converts @param fLOG logging function (warnings will be logged) @param writer *None* or an instance such as ``HTMLWriterWithCustomDirectives()`` or ``custom`` or ``sphinx`` @param keep_warnings keep_warnings in the final HTML @param directives new directives to add (see below) @param language language @param options Sphinx options see `Render math as images <http://www.sphinx-doc.org/en/stable/ext/math.html#module-sphinx.ext.imgmath>`_, a subset of options is used, see @see fn default_sphinx_options @param warnings_log send warnings to log (True) or to the warning stream(False) @return HTML format *directives* is None or a list of 5-uple: * a directive name * a directive class: see `Sphinx Directive <http://sphinx-doc.org/extdev/tutorial.html>`_, see also @see cl RunPythonDirective as an example * a docutils node: see @see cl runpython_node as an example * two functions: see @see fn visit_runpython_node, @see fn depart_runpython_node as an example .. exref:: :title: How to test a Sphinx directive? The following code defines a simple directive defined based on an existing one. It also defined what to do if a new node is inserted in the documentation. :: from docutils import nodes from pyquickhelper.helpgen import rst2html class runpythonthis_node(nodes.Structural, nodes.Element): pass class RunPythonThisDirective (RunPythonDirective): runpython_class = runpythonthis_node def visit_node(self, node): self.body.append("<p><b>visit_node</b></p>") def depart_node(self, node): self.body.append("<p><b>depart_node</b></p>") content = ''' test a directive ================ .. runpythonthis:: print("this code shoud appear" + "___") '''.replace(" ", "") # to remove spaces at the beginning of the line tives = [ ("runpythonthis", RunPythonThisDirective, runpythonthis_node, visit_node, depart_node) ] html = rst2html(content, fLOG=fLOG, writer="custom", keep_warnings=True, directives=tives) Unfortunately, this functionality is only tested on Python 3. It might only work on Python 2.7. The function produces files if the document contains latex converted into image. .. faqref:: :title: How to get more about latex errors? :index: latex Sphinx is not easy to use when it comes to debug latex expressions. I did not find an easy way to read the error returned by latex about a missing bracket or an unknown command. I fianlly added a short piece of code in ``sphinx.ext.imgmath.py`` just after the call to the executable indicated by *imgmath_latex* :: if b'...' in stdout or b'LaTeX Error' in stdout: print(self.builder.config.imgmath_latex_preamble) print(p.returncode) print("################") print(latex) print("..........") print(stdout.decode("ascii").replace("\r", "")) print("-----") print(stderr) It displays the output if an error happened. .. faqref:: :title: How to hide command line window while compiling latex? :lid: command line window Sphinx calls latex through command line. On Windows, a command line window can annoyingly show up anytime a formula is compile. The following line can be added to hide it: :: startupinfo = STARTUPINFO() startupinfo.dwFlags |= STARTF_USESHOWWINDOW And ``, startupinfo=startupinfo`` must be added to lines ``p = Popen(...``. .. versionadded:: 1.0 .. versionchanged:: 1.3 Parameters *writer*, *keep_warnings* were added to specifiy a custom writer and to keep the warnings. By default, the function now interprets *Sphinx* directives and not only *docutils* ones. Parameter *directives* was added to add a directive before parsing the RST. .. versionchanged:: 1.4 Add directives *todoext*, *todo*, *mathdef*, *blocref*, *faqref*,*nbref*, *exref*, parameter *language* was added. Add directives *graphviz*, *math*. Parse more extensive Sphinx syntax. """ _nbeq = [0, None] def custom_html_visit_displaymath(self, node): if not hasattr(node, "number"): node["number"] = None try: return html_visit_displaymath(self, node) except AttributeError as e: if "math_number_all" in str(e) and sys.version_info[:2] <= (2, 7): # Python 2.7 produces the following error: # AttributeError: No such config value: math_number_all # we skip return [] else: raise e class MockSphinxApp: """ Mock Sphinx application """ def __init__(self, writer, app): self.app = app self.new_options = {} self.writer = writer self.mapping = {"<class 'sphinx.ext.todo.todo_node'>": "todo", "<class 'sphinx.ext.graphviz.graphviz'>": "graphviz", "<class 'sphinx.ext.mathbase.math'>": "math", "<class 'sphinx.ext.mathbase.displaymath'>": "displaymath", "<class 'sphinx.ext.mathbase.eqref'>": "eqref", "<class 'matplotlib.sphinxext.only_directives.html_only'>": "only", "<class 'matplotlib.sphinxext.only_directives.latex_only'>": "only", } self.mapping_connect = {} self.config = Config(None, None, overrides={}, tags=None) self.confdir = "." self.doctreedir = "." self.builder = writer.builder self.domains = {} self._events = {} def add_directive(self, name, cl, *args, **options): doc_directives.register_directive(name, cl) self.mapping[str(cl)] = name self.app.add_directive(name, cl, *args, **options) def add_role(self, name, cl): doc_roles.register_canonical_role(name, cl) self.mapping[str(cl)] = name self.app.add_role(name, cl) def add_mapping(self, name, cl): self.mapping[str(cl)] = name def add_config_value(self, name, default, rebuild, types=()): if name in self.config.values: raise Exception('Config value %r already present' % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.new_options[name] = (default, rebuild, types) self.config.values[name] = (default, rebuild, types) def get_default_values(self): return {k: v[0] for k, v in self.new_options.items()} def add_node(self, clnode, html=None, latex=None, text=None, man=None, texinfo=None, override=True): if override and html is not None: name = str(clnode) if "displaymath" in name: self.writer.connect_directive_node( self.mapping[name], custom_html_visit_displaymath, html[1]) else: self.writer.connect_directive_node( self.mapping[name], html[0], html[1]) def connect(self, node, func): self.mapping_connect[node] = func self.app.connect(node, func) def add_domain(self, domain): if domain.name in self.domains: raise Exception( 'domain %s already registered' % domain.name) self.domains[domain.name] = domain def add_event(self, name): if name in self._events: raise Exception('Event %s already present' % name) self._events[name] = '' def emit(self, event, *args): return self.app.emit(event, *args) title_names = [] if writer in ["custom", "sphinx"]: writer = HTMLWriterWithCustomDirectives() writer_name = 'pseudoxml' mockapp = MockSphinxApp(writer, writer.app) from sphinx.ext.graphviz import setup as setup_graphviz from sphinx.ext.imgmath import setup as setup_math, html_visit_displaymath from sphinx.ext.todo import setup as setup_todo # directives from pyquickhelper setup_blog(mockapp) setup_runpython(mockapp) setup_sharenet(mockapp) setup_todoext(mockapp) setup_bigger(mockapp) setup_githublink(mockapp) setup_runpython(mockapp) setup_mathdef(mockapp) setup_blocref(mockapp) setup_faqref(mockapp) setup_exref(mockapp) setup_nbref(mockapp) # directives from sphinx setup_graphviz(mockapp) setup_math(mockapp) setup_todo(mockapp) # don't move this import to the beginning of file # it changes matplotlib backend from matplotlib.sphinxext.plot_directive import setup as setup_plot from matplotlib.sphinxext.only_directives import setup as setup_only setup_plot(mockapp) setup_only(mockapp) # titles title_names.append("todoext_node") title_names.append("todo_node") title_names.append("mathdef_node") title_names.append("blocref_node") title_names.append("faqref_node") title_names.append("nbref_node") title_names.append("exref_node") else: writer_name = 'html' mockapp = MockSphinxApp(None) if writer is None and directives is not None and len(directives) > 0: raise NotImplementedError( "the writer must not be null if custom directives will be added, check the documentation of the fucntion") if directives is not None: for tu in directives: if len(tu) != 5: raise ValueError( "directives is a list of tuple with 5 elements, check the documentation") name, cl, node, f1, f2 = tu doc_directives.register_directive(name, cl) # not necessary # nodes._add_node_class_names([node.__name__]) writer.connect_directive_node(node.__name__, f1, f2) settings_overrides = default_settings.copy() settings_overrides.update({k: v[0] for k, v in mockapp.new_options.items()}) # next defopt = default_sphinx_options(**options) settings_overrides.update(defopt) warning_stringio = defopt["warning_stream"] _nbeq[1] = warning_stringio config = mockapp.config config.init_values(fLOG) config.blog_background = False config.sharepost = None writer.add_configuration_options(mockapp.new_options) for k in {'outdir', 'imagedir', 'confdir', 'doctreedir'}: setattr(writer.builder, k, settings_overrides[k]) env = BuildEnvironment(None, None, config=config) env.temp_data["docname"] = "string" mockapp.builder.env.temp_data["docname"] = "string" settings_overrides["env"] = env lang = languages.get_language(language) for name in title_names: if name not in lang.labels: lang.labels[name] = TITLES[language][name] for k, v in sorted(settings_overrides.items()): fLOG("[rst2html] {0}={1}{2}".format( k, v, " --- added" if hasattr(config, k) else "")) for k, v in sorted(settings_overrides.items()): if hasattr(writer.builder.config, k) and writer.builder.config[k] != v: writer.builder.config[k] = v # something is screwing with sphinx or docutils, it is due to # direct call to nbconvert or sphinx # raise an exception for unknown role pending_xref output, pub = core.publish_programmatically(source=s, source_path=None, destination_path=None, writer=writer, writer_name=writer_name, settings_overrides=settings_overrides, source_class=StringInput, destination_class=StringOutput, destination=None, reader=None, reader_name='standalone', parser=None, parser_name='restructuredtext', settings=None, settings_spec=None, config_section=None, enable_exit_status=False) doctree = pub.document mockapp.emit('doctree-read', doctree) parts = pub.writer.parts warnval = settings_overrides["warning_stream"].getvalue() if warnval is not None and len(warnval) > 0: if warnings_log: fLOG(warnval) else: warnings.warn(warnval) if not keep_warnings: exp = re.sub( '(<div class="system-message">(.|\\n)*?</div>)', "", parts["whole"]) else: exp = parts["whole"] return exp
def merge(docs, otherenv): # type: (List[unicode], unicode) -> None env = BuildEnvironment.loads(otherenv) self.env.merge_info_from(docs, env, self.app)
def assign_section_numbers(self, env: BuildEnvironment) -> List[str]: """Assign a section number to each heading under a numbered toctree.""" # a list of all docnames whose section numbers changed rewrite_needed = [] assigned = set() # type: Set[str] old_secnumbers = env.toc_secnumbers env.toc_secnumbers = {} def _walk_toc(node: Element, secnums: Dict, depth: int, titlenode: nodes.title = None) -> None: # NOQA # titlenode is the title of the document, it will get assigned a # secnumber too, so that it shows up in next/prev/parent rellinks for subnode in node.children: if isinstance(subnode, nodes.bullet_list): numstack.append(0) _walk_toc(subnode, secnums, depth - 1, titlenode) numstack.pop() titlenode = None elif isinstance(subnode, nodes.list_item): _walk_toc(subnode, secnums, depth, titlenode) titlenode = None elif isinstance(subnode, addnodes.only): # at this stage we don't know yet which sections are going # to be included; just include all of them, even if it leads # to gaps in the numbering _walk_toc(subnode, secnums, depth, titlenode) titlenode = None elif isinstance(subnode, addnodes.compact_paragraph): numstack[-1] += 1 reference = cast(nodes.reference, subnode[0]) if depth > 0: number = list(numstack) secnums[reference['anchorname']] = tuple(numstack) else: number = None secnums[reference['anchorname']] = None reference['secnumber'] = number if titlenode: titlenode['secnumber'] = number titlenode = None elif isinstance(subnode, addnodes.toctree): _walk_toctree(subnode, depth) def _walk_toctree(toctreenode: addnodes.toctree, depth: int) -> None: if depth == 0: return for (title, ref) in toctreenode['entries']: if url_re.match(ref) or ref == 'self': # don't mess with those continue elif ref in assigned: logger.warning(__('%s is already assigned section numbers ' '(nested numbered toctree?)'), ref, location=toctreenode, type='toc', subtype='secnum') elif ref in env.tocs: secnums = {} # type: Dict[str, Tuple[int, ...]] env.toc_secnumbers[ref] = secnums assigned.add(ref) _walk_toc(env.tocs[ref], secnums, depth, env.titles.get(ref)) if secnums != old_secnumbers.get(ref): rewrite_needed.append(ref) for docname in env.numbered_toctrees: assigned.add(docname) doctree = env.get_doctree(docname) for toctreenode in doctree.traverse(addnodes.toctree): depth = toctreenode.get('numbered', 0) if depth: # every numbered toctree gets new numbering numstack = [0] _walk_toctree(toctreenode, depth) return rewrite_needed
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): # type: (unicode, unicode, unicode, unicode, unicode, Dict, IO, IO, bool, bool, List[unicode], int, int) -> None # NOQA self.verbosity = verbosity self.extensions = {} # type: Dict[unicode, Extension] self._setting_up_extension = ['?'] # type: List[unicode] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.registry = SphinxComponentRegistry() self.enumerable_nodes = { } # type: Dict[nodes.Node, Tuple[unicode, Callable]] # NOQA self.post_transforms = [] # type: List[Transform] self.html_themes = {} # type: Dict[unicode, unicode] self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() # type: IO else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror logging.setup(self, self._status, self._warning) self.events = EventManager() # keep last few messages for traceback # This will be filled by sphinx.util.logging.LastMessagesWriter self.messagelog = deque(maxlen=10) # type: deque # say hello to the world logger.info(bold('Running Sphinx v%s' % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): logger.info('making output directory...') os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode() # defer checking types until i18n has been initialized # initialize some limited config variables before initialize i18n and loading # extensions self.config.pre_init_values() # set up translation infrastructure self._init_i18n() # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( _('This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.') % self.config.needs_sphinx) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # preload builder module (before init config values) self.preload_builder(buildername) # the config file itself can be an extension if self.config.setup: self._setting_up_extension = ['conf.py'] # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, '__call__'): self.config.setup(self) else: raise ConfigError( _("'setup' as currently defined in conf.py isn't a Python callable. " "Please modify its definition to make it a callable function. This is " "needed for conf.py to behave as a Sphinx extension.")) # now that we know all config values, collect them from conf.py self.config.init_values() # check extension versions if requested verify_required_extensions(self, self.config.needs_extensions) # check primary_domain if requested primary_domain = self.config.primary_domain if primary_domain and not self.registry.has_domain(primary_domain): logger.warning(_('primary_domain %r not found, ignored.'), primary_domain) # create the builder self.builder = self.create_builder(buildername) # check all configuration values for permissible types self.config.check_types() # set up source_parsers self._init_source_parsers() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder() # set up the enumerable nodes self._init_enumerable_nodes() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: logger.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) user_locale_dirs = [ path.join(self.srcdir, x) for x in self.config.locale_dirs ] # compile mo files if sphinx.po file in user locale directories are updated for catinfo in find_catalog_source_files( user_locale_dirs, self.config.language, domains=['sphinx'], charset=self.config.source_encoding): catinfo.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale') ] + user_locale_dirs else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated logger.info(_('done')) else: logger.info('not available for built-in messages') def _init_source_parsers(self): # type: () -> None for suffix, parser in iteritems(self.config.source_parsers): self.add_source_parser(suffix, parser) for suffix, parser in iteritems(self.registry.get_source_parsers()): if suffix not in self.config.source_suffix and suffix != '*': self.config.source_suffix.append(suffix) def _init_env(self, freshenv): # type: (bool) -> None if freshenv: self.env = BuildEnvironment(self) self.env.find_files(self.config, self.builder) for domain in self.registry.create_domains(self.env): self.env.domains[domain.name] = domain else: try: logger.info(bold(_('loading pickled environment... ')), nonl=True) filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) self.env = BuildEnvironment.frompickle(filename, self) self.env.domains = {} for domain in self.registry.create_domains(self.env): # this can raise if the data version doesn't fit self.env.domains[domain.name] = domain logger.info(_('done')) except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: logger.info(_('not yet created')) else: logger.info(_('failed: %s'), err) self._init_env(freshenv=True) def preload_builder(self, name): # type: (unicode) -> None self.registry.preload_builder(self, name) def create_builder(self, name): # type: (unicode) -> Builder if name is None: logger.info(_('No builder selected, using default: html')) name = 'html' return self.registry.create_builder(self, name) def _init_builder(self): # type: () -> None self.builder.set_environment(self.env) self.builder.init() self.emit('builder-inited') def _init_enumerable_nodes(self): # type: () -> None for node, settings in iteritems(self.enumerable_nodes): self.env.get_domain( 'std').enumerable_nodes[node] = settings # type: ignore # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[unicode]) -> None try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = (self.statuscode == 0 and _('succeeded') or _('finished with problems')) if self._warncount: logger.info( bold( _('build %s, %s warning%s.') % (status, self._warncount, self._warncount != 1 and 's' or ''))) else: logger.info(bold(_('build %s.') % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def warn(self, message, location=None, type=None, subtype=None): # type: (unicode, unicode, unicode, unicode) -> None """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *type* and *subtype* are used to suppress warnings with :confval:`suppress_warnings`. """ warnings.warn( 'app.warning() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.warning(message, type=type, subtype=subtype, location=location) def info(self, message='', nonl=False): # type: (unicode, bool) -> None """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ warnings.warn( 'app.info() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.info(message, nonl=nonl) def verbose(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a verbose informational message.""" warnings.warn( 'app.verbose() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.verbose(message, *args, **kwargs) def debug(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a debug-level informational message.""" warnings.warn( 'app.debug() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) def debug2(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a lowlevel debug-level informational message.""" warnings.warn('app.debug2() is now deprecated. Use debug() instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) # ---- general extensibility interface ------------------------------------- def setup_extension(self, extname): # type: (unicode) -> None """Import and setup a Sphinx extension module. No-op if called twice.""" logger.debug('[app] setting up extension: %r', extname) self.registry.load_extension(self, extname) def require_sphinx(self, version): # type: (unicode) -> None # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): # type: (str, unicode) -> Any """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def connect(self, event, callback): # type: (unicode, Callable) -> int listener_id = self.events.connect(event, callback) logger.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None logger.debug('[app] disconnecting event: [id=%s]', listener_id) self.events.disconnect(listener_id) def emit(self, event, *args): # type: (unicode, Any) -> List try: logger.debug('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass return self.events.emit(event, self, *args) def emit_firstresult(self, event, *args): # type: (unicode, Any) -> Any return self.events.emit_firstresult(event, self, *args) # registering addon parts def add_builder(self, builder): # type: (Type[Builder]) -> None logger.debug('[app] adding builder: %r', builder) self.registry.add_builder(builder) def add_config_value(self, name, default, rebuild, types=()): # type: (unicode, Any, Union[bool, unicode], Any) -> None logger.debug('[app] adding config value: %r', (name, default, rebuild) + ((types, ) if types else ())) # type: ignore if name in self.config: raise ExtensionError(_('Config value %r already present') % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.add(name, default, rebuild, types) def add_event(self, name): # type: (unicode) -> None logger.debug('[app] adding event: %r', name) self.events.add(name) def set_translator(self, name, translator_class): # type: (unicode, Type[nodes.NodeVisitor]) -> None logger.info(bold(_('Change of translator for the %s builder.') % name)) self.registry.add_translator(name, translator_class) def add_node(self, node, **kwds): # type: (nodes.Node, Any) -> None logger.debug('[app] adding node: %r', (node, kwds)) if not kwds.pop('override', False) and \ hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__): logger.warning(_( 'while setting up extension %s: node class %r is ' 'already registered, its visitors will be overridden'), self._setting_up_extension, node.__name__, type='app', subtype='add_node') nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError( _('Value for key %r must be a ' '(visit, depart) function tuple') % key) translator = self.registry.translators.get(key) translators = [] if translator is not None: translators.append(translator) elif key == 'html': from sphinx.writers.html import HTMLTranslator translators.append(HTMLTranslator) if is_html5_writer_available(): from sphinx.writers.html5 import HTML5Translator translators.append(HTML5Translator) elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator translators.append(LaTeXTranslator) elif key == 'text': from sphinx.writers.text import TextTranslator translators.append(TextTranslator) elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator translators.append(ManualPageTranslator) elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator translators.append(TexinfoTranslator) for translator in translators: setattr(translator, 'visit_' + node.__name__, visit) if depart: setattr(translator, 'depart_' + node.__name__, depart) def add_enumerable_node(self, node, figtype, title_getter=None, **kwds): # type: (nodes.Node, unicode, Callable, Any) -> None self.enumerable_nodes[node] = (figtype, title_getter) self.add_node(node, **kwds) def add_directive(self, name, obj, content=None, arguments=None, **options): # type: (unicode, Any, bool, Tuple[int, int, bool], Any) -> None logger.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) if name in directives._directives: logger.warning(_('while setting up extension %s: directive %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_directive') directive = directive_helper(obj, content, arguments, **options) directives.register_directive(name, directive) def add_role(self, name, role): # type: (unicode, Any) -> None logger.debug('[app] adding role: %r', (name, role)) if name in roles._roles: logger.warning(_('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_role') roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # type: (unicode, Any) -> None # don't use roles.register_generic_role because it uses # register_canonical_role logger.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: logger.warning(_('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] adding domain: %r', domain) self.registry.add_domain(domain) def override_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] overriding domain: %r', domain) self.registry.override_domain(domain) def add_directive_to_domain(self, domain, name, obj, has_content=None, argument_spec=None, **option_spec): # type: (unicode, unicode, Any, bool, Any, Any) -> None logger.debug( '[app] adding directive to domain: %r', (domain, name, obj, has_content, argument_spec, option_spec)) self.registry.add_directive_to_domain(domain, name, obj, has_content, argument_spec, **option_spec) def add_role_to_domain(self, domain, name, role): # type: (unicode, unicode, Any) -> None logger.debug('[app] adding role to domain: %r', (domain, name, role)) self.registry.add_role_to_domain(domain, name, role) def add_index_to_domain(self, domain, index): # type: (unicode, Type[Index]) -> None logger.debug('[app] adding index to domain: %r', (domain, index)) self.registry.add_index_to_domain(domain, index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None logger.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) self.registry.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types) def add_description_unit(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None warnings.warn( 'app.add_description_unit() is now deprecated. ' 'Use app.add_object_type() instead.', RemovedInSphinx20Warning) self.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types) def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): # type: (unicode, unicode, unicode, nodes.Node, unicode) -> None logger.debug( '[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) self.registry.add_crossref_type(directivename, rolename, indextemplate, ref_nodeclass, objname) def add_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_post_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding post transform: %r', transform) self.post_transforms.append(transform) def add_javascript(self, filename): # type: (unicode) -> None logger.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename, alternate=False, title=None): # type: (unicode, bool, unicode) -> None logger.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder, Stylesheet if '://' not in filename: filename = posixpath.join('_static', filename) if alternate: rel = u'alternate stylesheet' else: rel = u'stylesheet' css = Stylesheet(filename, title, rel) # type: ignore StandaloneHTMLBuilder.css_files.append(css) def add_latex_package(self, packagename, options=None): # type: (unicode, unicode) -> None logger.debug('[app] adding latex package: %r', packagename) if hasattr(self.builder, 'usepackages'): # only for LaTeX builder self.builder.usepackages.append( (packagename, options)) # type: ignore def add_lexer(self, alias, lexer): # type: (unicode, Any) -> None logger.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): # type: (Any) -> None logger.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): # type: (Any, Callable) -> None logger.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): # type: (Any) -> None logger.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_parser(self, suffix, parser): # type: (unicode, Parser) -> None logger.debug('[app] adding search source_parser: %r, %r', suffix, parser) self.registry.add_source_parser(suffix, parser) def add_env_collector(self, collector): # type: (Type[EnvironmentCollector]) -> None logger.debug('[app] adding environment collector: %r', collector) collector().enable(self) def add_html_theme(self, name, theme_path): # type: (unicode, unicode) -> None logger.debug('[app] adding HTML theme: %r, %r', name, theme_path) self.html_themes[name] = theme_path
def merge_other(self, app: Sphinx, env: BuildEnvironment, docnames: Set[str], other: BuildEnvironment) -> None: for docname in docnames: if docname in other.dependencies: env.dependencies[docname] = other.dependencies[docname]
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): # type: (unicode, unicode, unicode, unicode, unicode, Dict, IO, IO, bool, bool, List[unicode], int, int) -> None # NOQA self.verbosity = verbosity self.extensions = {} # type: Dict[unicode, Extension] self._setting_up_extension = ['?'] # type: List[unicode] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.registry = SphinxComponentRegistry() self.enumerable_nodes = {} # type: Dict[nodes.Node, Tuple[unicode, Callable]] # NOQA self.post_transforms = [] # type: List[Transform] self.html_themes = {} # type: Dict[unicode, unicode] self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() # type: IO else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror logging.setup(self, self._status, self._warning) self.events = EventManager() # keep last few messages for traceback # This will be filled by sphinx.util.logging.LastMessagesWriter self.messagelog = deque(maxlen=10) # type: deque # say hello to the world logger.info(bold('Running Sphinx v%s' % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): logger.info('making output directory...') os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode() # defer checking types until i18n has been initialized # initialize some limited config variables before initialize i18n and loading # extensions self.config.pre_init_values() # set up translation infrastructure self._init_i18n() # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( __('This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.') % self.config.needs_sphinx) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # preload builder module (before init config values) self.preload_builder(buildername) # the config file itself can be an extension if self.config.setup: self._setting_up_extension = ['conf.py'] # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, '__call__'): self.config.setup(self) else: raise ConfigError( __("'setup' as currently defined in conf.py isn't a Python callable. " "Please modify its definition to make it a callable function. This is " "needed for conf.py to behave as a Sphinx extension.") ) # now that we know all config values, collect them from conf.py self.config.init_values() # check extension versions if requested verify_required_extensions(self, self.config.needs_extensions) # check primary_domain if requested primary_domain = self.config.primary_domain if primary_domain and not self.registry.has_domain(primary_domain): logger.warning(__('primary_domain %r not found, ignored.'), primary_domain) # create the builder self.builder = self.create_builder(buildername) # check all configuration values for permissible types self.config.check_types() # set up source_parsers self._init_source_parsers() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder() # set up the enumerable nodes self._init_enumerable_nodes() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: logger.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) user_locale_dirs = [ path.join(self.srcdir, x) for x in self.config.locale_dirs] # compile mo files if sphinx.po file in user locale directories are updated for catinfo in find_catalog_source_files( user_locale_dirs, self.config.language, domains=['sphinx'], charset=self.config.source_encoding): catinfo.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale')] + user_locale_dirs else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated logger.info(__('done')) else: logger.info('not available for built-in messages') def _init_source_parsers(self): # type: () -> None for suffix, parser in iteritems(self.config.source_parsers): self.add_source_parser(suffix, parser) for suffix, parser in iteritems(self.registry.get_source_parsers()): if suffix not in self.config.source_suffix and suffix != '*': self.config.source_suffix.append(suffix) def _init_env(self, freshenv): # type: (bool) -> None if freshenv: self.env = BuildEnvironment(self) self.env.find_files(self.config, self.builder) for domain in self.registry.create_domains(self.env): self.env.domains[domain.name] = domain else: try: logger.info(bold(__('loading pickled environment... ')), nonl=True) filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) self.env = BuildEnvironment.frompickle(filename, self) self.env.domains = {} for domain in self.registry.create_domains(self.env): # this can raise if the data version doesn't fit self.env.domains[domain.name] = domain logger.info(__('done')) except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: logger.info(__('not yet created')) else: logger.info(__('failed: %s'), err) self._init_env(freshenv=True) def preload_builder(self, name): # type: (unicode) -> None self.registry.preload_builder(self, name) def create_builder(self, name): # type: (unicode) -> Builder if name is None: logger.info(__('No builder selected, using default: html')) name = 'html' return self.registry.create_builder(self, name) def _init_builder(self): # type: () -> None self.builder.set_environment(self.env) self.builder.init() self.emit('builder-inited') def _init_enumerable_nodes(self): # type: () -> None for node, settings in iteritems(self.enumerable_nodes): self.env.get_domain('std').enumerable_nodes[node] = settings # type: ignore @property def buildername(self): # type: () -> unicode warnings.warn('app.buildername is deprecated. Please use app.builder.name instead', RemovedInSphinx17Warning) return self.builder.name # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[unicode]) -> None try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = (self.statuscode == 0 and __('succeeded') or __('finished with problems')) if self._warncount: logger.info(bold(__('build %s, %s warning%s.') % (status, self._warncount, self._warncount != 1 and 's' or ''))) else: logger.info(bold(__('build %s.') % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def warn(self, message, location=None, prefix=None, type=None, subtype=None, colorfunc=None): # type: (unicode, unicode, unicode, unicode, unicode, Callable) -> None """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. *type* and *subtype* are used to suppress warnings with :confval:`suppress_warnings`. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if prefix: warnings.warn('prefix option of warn() is now deprecated.', RemovedInSphinx17Warning) if colorfunc: warnings.warn('colorfunc option of warn() is now deprecated.', RemovedInSphinx17Warning) warnings.warn('app.warning() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.warning(message, type=type, subtype=subtype, location=location) def info(self, message='', nonl=False): # type: (unicode, bool) -> None """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ warnings.warn('app.info() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.info(message, nonl=nonl) def verbose(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a verbose informational message.""" warnings.warn('app.verbose() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.verbose(message, *args, **kwargs) def debug(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a debug-level informational message.""" warnings.warn('app.debug() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) def debug2(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a lowlevel debug-level informational message.""" warnings.warn('app.debug2() is now deprecated. Use debug() instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) def _display_chunk(chunk): # type: (Any) -> unicode warnings.warn('app._display_chunk() is now deprecated. ' 'Use sphinx.util.display_chunk() instead.', RemovedInSphinx17Warning) return display_chunk(chunk) def old_status_iterator(self, iterable, summary, colorfunc=darkgreen, stringify_func=display_chunk): # type: (Iterable, unicode, Callable, Callable[[Any], unicode]) -> Iterator warnings.warn('app.old_status_iterator() is now deprecated. ' 'Use sphinx.util.status_iterator() instead.', RemovedInSphinx17Warning) for item in old_status_iterator(iterable, summary, color="darkgreen", stringify_func=stringify_func): yield item # new version with progress info def status_iterator(self, iterable, summary, colorfunc=darkgreen, length=0, stringify_func=_display_chunk): # type: (Iterable, unicode, Callable, int, Callable[[Any], unicode]) -> Iterable warnings.warn('app.status_iterator() is now deprecated. ' 'Use sphinx.util.status_iterator() instead.', RemovedInSphinx17Warning) for item in status_iterator(iterable, summary, length=length, verbosity=self.verbosity, color="darkgreen", stringify_func=stringify_func): yield item # ---- general extensibility interface ------------------------------------- def setup_extension(self, extname): # type: (unicode) -> None """Import and setup a Sphinx extension module. No-op if called twice.""" logger.debug('[app] setting up extension: %r', extname) self.registry.load_extension(self, extname) def require_sphinx(self, version): # type: (unicode) -> None # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): # type: (str, unicode) -> Any """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def connect(self, event, callback): # type: (unicode, Callable) -> int listener_id = self.events.connect(event, callback) logger.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None logger.debug('[app] disconnecting event: [id=%s]', listener_id) self.events.disconnect(listener_id) def emit(self, event, *args): # type: (unicode, Any) -> List try: logger.debug('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass return self.events.emit(event, self, *args) def emit_firstresult(self, event, *args): # type: (unicode, Any) -> Any return self.events.emit_firstresult(event, self, *args) # registering addon parts def add_builder(self, builder): # type: (Type[Builder]) -> None logger.debug('[app] adding builder: %r', builder) self.registry.add_builder(builder) def add_config_value(self, name, default, rebuild, types=()): # type: (unicode, Any, Union[bool, unicode], Any) -> None logger.debug('[app] adding config value: %r', (name, default, rebuild) + ((types,) if types else ())) # type: ignore if name in self.config: raise ExtensionError(__('Config value %r already present') % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.add(name, default, rebuild, types) def add_event(self, name): # type: (unicode) -> None logger.debug('[app] adding event: %r', name) self.events.add(name) def set_translator(self, name, translator_class): # type: (unicode, Type[nodes.NodeVisitor]) -> None logger.info(bold(__('Change of translator for the %s builder.') % name)) self.registry.add_translator(name, translator_class) def add_node(self, node, **kwds): # type: (nodes.Node, Any) -> None logger.debug('[app] adding node: %r', (node, kwds)) if not kwds.pop('override', False) and \ hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__): logger.warning(__('while setting up extension %s: node class %r is ' 'already registered, its visitors will be overridden'), self._setting_up_extension, node.__name__, type='app', subtype='add_node') nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError(__('Value for key %r must be a ' '(visit, depart) function tuple') % key) translator = self.registry.translators.get(key) translators = [] if translator is not None: translators.append(translator) elif key == 'html': from sphinx.writers.html import HTMLTranslator translators.append(HTMLTranslator) if is_html5_writer_available(): from sphinx.writers.html5 import HTML5Translator translators.append(HTML5Translator) elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator translators.append(LaTeXTranslator) elif key == 'text': from sphinx.writers.text import TextTranslator translators.append(TextTranslator) elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator translators.append(ManualPageTranslator) elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator translators.append(TexinfoTranslator) for translator in translators: setattr(translator, 'visit_' + node.__name__, visit) if depart: setattr(translator, 'depart_' + node.__name__, depart) def add_enumerable_node(self, node, figtype, title_getter=None, **kwds): # type: (nodes.Node, unicode, Callable, Any) -> None self.enumerable_nodes[node] = (figtype, title_getter) self.add_node(node, **kwds) def _directive_helper(self, obj, has_content=None, argument_spec=None, **option_spec): # type: (Any, bool, Tuple[int, int, bool], Any) -> Any warnings.warn('_directive_helper() is now deprecated. ' 'Please use sphinx.util.docutils.directive_helper() instead.', RemovedInSphinx17Warning) return directive_helper(obj, has_content, argument_spec, **option_spec) def add_directive(self, name, obj, content=None, arguments=None, **options): # type: (unicode, Any, bool, Tuple[int, int, bool], Any) -> None logger.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) if name in directives._directives: logger.warning(__('while setting up extension %s: directive %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_directive') directive = directive_helper(obj, content, arguments, **options) directives.register_directive(name, directive) def add_role(self, name, role): # type: (unicode, Any) -> None logger.debug('[app] adding role: %r', (name, role)) if name in roles._roles: logger.warning(__('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_role') roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # type: (unicode, Any) -> None # don't use roles.register_generic_role because it uses # register_canonical_role logger.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: logger.warning(__('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] adding domain: %r', domain) self.registry.add_domain(domain) def override_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] overriding domain: %r', domain) self.registry.override_domain(domain) def add_directive_to_domain(self, domain, name, obj, has_content=None, argument_spec=None, **option_spec): # type: (unicode, unicode, Any, bool, Any, Any) -> None logger.debug('[app] adding directive to domain: %r', (domain, name, obj, has_content, argument_spec, option_spec)) self.registry.add_directive_to_domain(domain, name, obj, has_content, argument_spec, **option_spec) def add_role_to_domain(self, domain, name, role): # type: (unicode, unicode, Any) -> None logger.debug('[app] adding role to domain: %r', (domain, name, role)) self.registry.add_role_to_domain(domain, name, role) def add_index_to_domain(self, domain, index): # type: (unicode, Type[Index]) -> None logger.debug('[app] adding index to domain: %r', (domain, index)) self.registry.add_index_to_domain(domain, index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None logger.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) self.registry.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types) def add_description_unit(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None warnings.warn('app.add_description_unit() is now deprecated. ' 'Use app.add_object_type() instead.', RemovedInSphinx20Warning) self.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types) def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): # type: (unicode, unicode, unicode, nodes.Node, unicode) -> None logger.debug('[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) self.registry.add_crossref_type(directivename, rolename, indextemplate, ref_nodeclass, objname) def add_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_post_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding post transform: %r', transform) self.post_transforms.append(transform) def add_javascript(self, filename): # type: (unicode) -> None logger.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename, alternate=False, title=None): # type: (unicode, bool, unicode) -> None logger.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder, Stylesheet if '://' not in filename: filename = posixpath.join('_static', filename) if alternate: rel = u'alternate stylesheet' else: rel = u'stylesheet' css = Stylesheet(filename, title, rel) # type: ignore StandaloneHTMLBuilder.css_files.append(css) def add_latex_package(self, packagename, options=None): # type: (unicode, unicode) -> None logger.debug('[app] adding latex package: %r', packagename) if hasattr(self.builder, 'usepackages'): # only for LaTeX builder self.builder.usepackages.append((packagename, options)) # type: ignore def add_lexer(self, alias, lexer): # type: (unicode, Any) -> None logger.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): # type: (Any) -> None logger.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): # type: (Any, Callable) -> None logger.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): # type: (Any) -> None logger.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_parser(self, suffix, parser): # type: (unicode, Parser) -> None logger.debug('[app] adding search source_parser: %r, %r', suffix, parser) self.registry.add_source_parser(suffix, parser) def add_env_collector(self, collector): # type: (Type[EnvironmentCollector]) -> None logger.debug('[app] adding environment collector: %r', collector) collector().enable(self) def add_html_theme(self, name, theme_path): # type: (unicode, unicode) -> None logger.debug('[app] adding HTML theme: %r, %r', name, theme_path) self.html_themes[name] = theme_path
def __init__(self, *args, **kwargs): self.main_tocs = {} BuildEnvironment.__init__(self, *args, **kwargs)
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} self._listeners = {} self.domains = BUILTIN_DOMAINS.copy() self.builderclasses = BUILTIN_BUILDERS.copy() self.builder = None self.env = None self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = StringIO() self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = StringIO() else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() # say hello to the world self.info(bold('Running Sphinx v%s' % sphinx.__version__)) # status code for command-line application self.statuscode = 0 # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # backwards compatibility: activate old C markup self.setup_extension('sphinx.ext.oldcmarkup') # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: self.config.setup(self) # now that we know all config values, collect them from conf.py self.config.init_values() # check the Sphinx version if requested if self.config.needs_sphinx and \ self.config.needs_sphinx > sphinx.__version__[:3]: raise VersionRequirementError( 'This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.' % self.config.needs_sphinx) # set up translation infrastructure self._init_i18n() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(buildername) def _init_i18n(self): """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) locale_dirs = [None, path.join(package_dir, 'locale')] + \ [path.join(self.srcdir, x) for x in self.config.locale_dirs] else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated self.info('done') else: self.info('not available for built-in messages') def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle( self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception, err: if type(err) is IOError and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn)
def __init__(self, filename, encoding="utf8", raise_exception=False): """ create an instance of a blog post from a file or a string @param filename filename or string @param encoding encoding @param raise_exception to raise an exception when the blog cannot be parsed The constructor creates the following members: * title * date * keywords * categories * _filename * _raw * rst_obj: the object generated by docutils (@see cl BlogPostDirective) * pub: Publisher .. versionchanged:: 1.3 Parameter *raise_exception* was added to catch the standard error. The constructor aims at getting the text of a blog post, not interpreting it. The code used to throw warnings or errors due to unreferenced nodes. """ if os.path.exists(filename): with open(filename, "r", encoding=encoding) as f: try: content = f.read() except UnicodeDecodeError as e: raise Exception( 'unable to read filename (encoding issue):\n File "{0}", line 1'.format(filename)) from e self._filename = filename else: content = filename self._filename = None self._raw = content overrides = {} overrides['input_encoding'] = encoding overrides["out_blogpostlist"] = [] overrides["blog_background"] = False overrides["sharepost"] = None overrides.update({'doctitle_xform': True, 'initial_header_level': 2, 'warning_stream': StringIO(), 'out_blogpostlist': [], 'out_runpythonlist': [], }) config = Config(None, None, overrides=overrides, tags=None) config.blog_background = False config.sharepost = None env = BuildEnvironment(None, None, config=config) env.temp_data["docname"] = "string" overrides["env"] = env errst = sys.stderr keeperr = StringIO() sys.stderr = keeperr output, pub = publish_programmatically( source_class=docio.StringInput, source=content, source_path=None, destination_class=docio.StringOutput, destination=None, destination_path=None, reader=None, reader_name='standalone', parser=None, parser_name='restructuredtext', writer=None, writer_name='null', settings=None, settings_spec=None, settings_overrides=overrides, config_section=None, enable_exit_status=None) sys.stderr = errst all_err = keeperr.getvalue() if len(all_err) > 0: if raise_exception: raise BlogPostParseError("unable to parse a blogpost:\nERR:\n{0}\nFILE\n{1}\nCONTENT\n{2}".format( all_err, self._filename, content)) else: # we assume we just need the content, raising a warnings # might make some process fail later # warnings.warn("Raw rst was caught but unable to fully parse a blogpost:\nERR:\n{0}\nFILE\n{1}\nCONTENT\n{2}".format( # all_err, self._filename, content)) pass # document = pub.writer.document objects = pub.settings.out_blogpostlist if len(objects) != 1: raise BlogPostParseError( 'no blog post (#={1}) in\n File "{0}", line 1'.format(filename, len(objects))) post = objects[0] for k in post.options: setattr(self, k, post.options[k]) self.rst_obj = post self.pub = pub self._content = post.content
def generate_notebook_outputs( env: BuildEnvironment, ntbk: nbf.NotebookNode, file_path: Optional[str] = None, show_traceback: bool = False, ) -> nbf.NotebookNode: """ Add outputs to a NotebookNode by pulling from cache. Function to get the database instance. Get the cached output of the notebook and merge it with the original notebook. If there is no cached output, checks if there was error during execution, then saves the traceback to a log file. """ # check if the file is of a format that may be associated with outputs if not is_valid_exec_file(env, env.docname): return ntbk # If we have a jupyter_cache, see if there's a cache for this notebook file_path = file_path or env.doc2path(env.docname) execution_method = env.config["jupyter_execute_notebooks"] # type: str path_to_cache = env.nb_path_to_cache if "cache" in execution_method else None if not path_to_cache and "off" in execution_method: return ntbk if not path_to_cache: if execution_method == "auto" and nb_has_all_output(file_path): LOGGER.info( "Did not execute %s. " "Set jupyter_execute_notebooks to `force` to execute", env.docname, ) else: if env.config["execution_in_temp"]: with tempfile.TemporaryDirectory() as tmpdirname: LOGGER.info("Executing: %s in temporary directory", env.docname) result = single_nb_execution( ntbk, cwd=tmpdirname, timeout=env.config["execution_timeout"], allow_errors=env.config["execution_allow_errors"], ) else: cwd = Path(file_path).parent LOGGER.info("Executing: %s in: %s", env.docname, cwd) result = single_nb_execution( ntbk, cwd=cwd, timeout=env.config["execution_timeout"], allow_errors=env.config["execution_allow_errors"], ) report_path = None if result.err: report_path, message = _report_exec_fail( env, Path(file_path).name, result.exc_string, show_traceback, "Execution Failed with traceback saved in {}", ) LOGGER.error(message) ntbk = result.nb env.nb_execution_data_changed = True env.nb_execution_data[env.docname] = { "mtime": datetime.now().timestamp(), "runtime": result.time, "method": execution_method, "succeeded": False if result.err else True, } if report_path: env.nb_execution_data[env.docname]["error_log"] = report_path return ntbk cache_base = get_cache(path_to_cache) # Use relpath here in case Sphinx is building from a non-parent folder r_file_path = Path(os.path.relpath(file_path, Path().resolve())) # default execution data runtime = None succeeded = False report_path = None try: pk, ntbk = cache_base.merge_match_into_notebook(ntbk) except KeyError: message = ( f"Couldn't find cache key for notebook file {str(r_file_path)}. " "Outputs will not be inserted.") try: stage_record = cache_base.get_staged_record(file_path) except KeyError: stage_record = None if stage_record and stage_record.traceback: report_path, suffix = _report_exec_fail( env, r_file_path.name, stage_record.traceback, show_traceback, "\n Last execution failed with traceback saved in {}", ) message += suffix LOGGER.error(message) else: LOGGER.verbose("Merged cached outputs into %s", str(r_file_path)) succeeded = True try: runtime = cache_base.get_cache_record(pk).data.get( "execution_seconds", None) except Exception: pass env.nb_execution_data_changed = True env.nb_execution_data[env.docname] = { "mtime": datetime.now().timestamp(), "runtime": runtime, "method": execution_method, "succeeded": succeeded, } if report_path: env.nb_execution_data[env.docname]["error_log"] = report_path return ntbk
def missing_reference(app: Sphinx, env: BuildEnvironment, node: Element, contnode: TextElement) -> nodes.reference: """Attempt to resolve a missing reference via intersphinx references.""" target = node['reftarget'] inventories = InventoryAdapter(env) objtypes = None # type: List[str] if node['reftype'] == 'any': # we search anything! objtypes = [ '%s:%s' % (domain.name, objtype) for domain in env.domains.values() for objtype in domain.object_types ] domain = None else: domain = node.get('refdomain') if not domain: # only objects in domains are in the inventory return None objtypes = env.get_domain(domain).objtypes_for_role(node['reftype']) if not objtypes: return None objtypes = ['%s:%s' % (domain, objtype) for objtype in objtypes] if 'std:cmdoption' in objtypes: # until Sphinx-1.6, cmdoptions are stored as std:option objtypes.append('std:option') to_try = [(inventories.main_inventory, target)] if domain: full_qualified_name = env.get_domain(domain).get_full_qualified_name( node) if full_qualified_name: to_try.append((inventories.main_inventory, full_qualified_name)) in_set = None if ':' in target: # first part may be the foreign doc set name setname, newtarget = target.split(':', 1) if setname in inventories.named_inventory: in_set = setname to_try.append((inventories.named_inventory[setname], newtarget)) if domain: node['reftarget'] = newtarget full_qualified_name = env.get_domain( domain).get_full_qualified_name(node) if full_qualified_name: to_try.append((inventories.named_inventory[setname], full_qualified_name)) for inventory, target in to_try: for objtype in objtypes: if objtype not in inventory or target not in inventory[objtype]: continue proj, version, uri, dispname = inventory[objtype][target] if '://' not in uri and node.get('refdoc'): # get correct path in case of subdirectories uri = path.join(relative_path(node['refdoc'], '.'), uri) if version: reftitle = _('(in %s v%s)') % (proj, version) else: reftitle = _('(in %s)') % (proj, ) newnode = nodes.reference('', '', internal=False, refuri=uri, reftitle=reftitle) if node.get('refexplicit'): # use whatever title was given newnode.append(contnode) elif dispname == '-' or \ (domain == 'std' and node['reftype'] == 'keyword'): # use whatever title was given, but strip prefix title = contnode.astext() if in_set and title.startswith(in_set + ':'): newnode.append( contnode.__class__(title[len(in_set) + 1:], title[len(in_set) + 1:])) else: newnode.append(contnode) else: # else use the given display name (used for :ref:) newnode.append(contnode.__class__(dispname, dispname)) return newnode # at least get rid of the ':' in the target if no explicit title given if in_set is not None and not node.get('refexplicit', True): if len(contnode) and isinstance(contnode[0], nodes.Text): contnode[0] = nodes.Text(newtarget, contnode[0].rawsource) return None
def purge_todos(app: Sphinx, env: BuildEnvironment, docname: str) -> None: warnings.warn('purge_todos() is deprecated.', RemovedInSphinx40Warning, stacklevel=2) if not hasattr(env, 'todo_all_todos'): return env.todo_all_todos = [todo for todo in env.todo_all_todos # type: ignore if todo['docname'] != docname]
class Sphinx: """The main application class and extensibility interface. :ivar srcdir: Directory containing source. :ivar confdir: Directory containing ``conf.py``. :ivar doctreedir: Directory for storing pickled doctrees. :ivar outdir: Directory for storing build documents. """ def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0, keep_going=False): # type: (str, str, str, str, str, Dict, IO, IO, bool, bool, List[str], int, int, bool) -> None # NOQA self.phase = BuildPhase.INITIALIZATION self.verbosity = verbosity self.extensions = {} # type: Dict[str, Extension] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.project = None # type: Project self.registry = SphinxComponentRegistry() self.html_themes = {} # type: Dict[str, str] # validate provided directories self.srcdir = abspath(srcdir) self.outdir = abspath(outdir) self.doctreedir = abspath(doctreedir) self.confdir = confdir if self.confdir: # confdir is optional self.confdir = abspath(self.confdir) if not path.isfile(path.join(self.confdir, 'conf.py')): raise ApplicationError(__("config directory doesn't contain a " "conf.py file (%s)") % confdir) if not path.isdir(self.srcdir): raise ApplicationError(__('Cannot find source directory (%s)') % self.srcdir) if self.srcdir == self.outdir: raise ApplicationError(__('Source directory and destination ' 'directory cannot be identical')) self.parallel = parallel if status is None: self._status = StringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = StringIO() # type: IO else: self._warning = warning self._warncount = 0 self.keep_going = warningiserror and keep_going if self.keep_going: self.warningiserror = False else: self.warningiserror = warningiserror logging.setup(self, self._status, self._warning) self.events = EventManager() # keep last few messages for traceback # This will be filled by sphinx.util.logging.LastMessagesWriter self.messagelog = deque(maxlen=10) # type: deque # say hello to the world logger.info(bold(__('Running Sphinx v%s') % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 # read config self.tags = Tags(tags) if self.confdir is None: self.config = Config({}, confoverrides or {}) else: self.config = Config.read(self.confdir, confoverrides or {}, self.tags) # initialize some limited config variables before initialize i18n and loading # extensions self.config.pre_init_values() # set up translation infrastructure self._init_i18n() # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( __('This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.') % self.config.needs_sphinx) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # preload builder module (before init config values) self.preload_builder(buildername) if not path.isdir(outdir): with progress_message(__('making output directory')): ensuredir(outdir) # the config file itself can be an extension if self.config.setup: prefix = __('while setting up extension %s:') % "conf.py" with prefixed_warnings(prefix): if callable(self.config.setup): self.config.setup(self) else: raise ConfigError( __("'setup' as currently defined in conf.py isn't a Python callable. " "Please modify its definition to make it a callable function. " "This is needed for conf.py to behave as a Sphinx extension.") ) # now that we know all config values, collect them from conf.py self.config.init_values() self.emit('config-inited', self.config) # create the project self.project = Project(self.srcdir, self.config.source_suffix) # create the builder self.builder = self.create_builder(buildername) # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: logger.info(bold(__('loading translations [%s]... ') % self.config.language), nonl=True) user_locale_dirs = [ path.join(self.srcdir, x) for x in self.config.locale_dirs] # compile mo files if sphinx.po file in user locale directories are updated for catinfo in find_catalog_source_files( user_locale_dirs, self.config.language, domains=['sphinx'], charset=self.config.source_encoding): catinfo.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale')] + user_locale_dirs else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated logger.info(__('done')) else: logger.info(__('not available for built-in messages')) def _init_env(self, freshenv): # type: (bool) -> None filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if freshenv or not os.path.exists(filename): self.env = BuildEnvironment() self.env.setup(self) self.env.find_files(self.config, self.builder) else: try: with progress_message(__('loading pickled environment')): with open(filename, 'rb') as f: self.env = pickle.load(f) self.env.setup(self) except Exception as err: logger.info(__('failed: %s'), err) self._init_env(freshenv=True) def preload_builder(self, name): # type: (str) -> None self.registry.preload_builder(self, name) def create_builder(self, name): # type: (str) -> Builder if name is None: logger.info(__('No builder selected, using default: html')) name = 'html' return self.registry.create_builder(self, name) def _init_builder(self): # type: () -> None self.builder.set_environment(self.env) self.builder.init() self.emit('builder-inited') # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[str]) -> None self.phase = BuildPhase.READING try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() if self._warncount and self.keep_going: self.statuscode = 1 status = (self.statuscode == 0 and __('succeeded') or __('finished with problems')) if self._warncount: logger.info(bold(__('build %s, %s warning.', 'build %s, %s warnings.', self._warncount) % (status, self._warncount))) else: logger.info(bold(__('build %s.') % status)) if self.statuscode == 0 and self.builder.epilog: logger.info('') logger.info(self.builder.epilog % { 'outdir': relpath(self.outdir), 'project': self.config.project }) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- general extensibility interface ------------------------------------- def setup_extension(self, extname): # type: (str) -> None """Import and setup a Sphinx extension module. Load the extension given by the module *name*. Use this if your extension needs the features provided by another extension. No-op if called twice. """ logger.debug('[app] setting up extension: %r', extname) self.registry.load_extension(self, extname) def require_sphinx(self, version): # type: (str) -> None """Check the Sphinx version if requested. Compare *version* (which must be a ``major.minor`` version string, e.g. ``'1.1'``) with the version of the running Sphinx, and abort the build when it is too old. .. versionadded:: 1.0 """ if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): # type: (str, str) -> Any """Import an object from a ``module.name`` string. .. deprecated:: 1.8 Use ``sphinx.util.import_object()`` instead. """ warnings.warn('app.import_object() is deprecated. ' 'Use sphinx.util.add_object_type() instead.', RemovedInSphinx30Warning, stacklevel=2) return import_object(objname, source=None) # event interface def connect(self, event, callback): # type: (str, Callable) -> int """Register *callback* to be called when *event* is emitted. For details on available core events and the arguments of callback functions, please see :ref:`events`. The method returns a "listener ID" that can be used as an argument to :meth:`disconnect`. """ listener_id = self.events.connect(event, callback) logger.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None """Unregister callback by *listener_id*.""" logger.debug('[app] disconnecting event: [id=%s]', listener_id) self.events.disconnect(listener_id) def emit(self, event, *args): # type: (str, Any) -> List """Emit *event* and pass *arguments* to the callback functions. Return the return values of all callbacks as a list. Do not emit core Sphinx events in extensions! """ try: logger.debug('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass return self.events.emit(event, self, *args) def emit_firstresult(self, event, *args): # type: (str, Any) -> Any """Emit *event* and pass *arguments* to the callback functions. Return the result of the first callback that doesn't return ``None``. .. versionadded:: 0.5 """ return self.events.emit_firstresult(event, self, *args) # registering addon parts def add_builder(self, builder, override=False): # type: (Type[Builder], bool) -> None """Register a new builder. *builder* must be a class that inherits from :class:`~sphinx.builders.Builder`. .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_builder(builder, override=override) # TODO(stephenfin): Describe 'types' parameter def add_config_value(self, name, default, rebuild, types=()): # type: (str, Any, Union[bool, str], Any) -> None """Register a configuration value. This is necessary for Sphinx to recognize new values and set default values accordingly. The *name* should be prefixed with the extension name, to avoid clashes. The *default* value can be any Python object. The string value *rebuild* must be one of those values: * ``'env'`` if a change in the setting only takes effect when a document is parsed -- this means that the whole environment must be rebuilt. * ``'html'`` if a change in the setting needs a full rebuild of HTML documents. * ``''`` if a change in the setting will not need any special rebuild. .. versionchanged:: 0.6 Changed *rebuild* from a simple boolean (equivalent to ``''`` or ``'env'``) to a string. However, booleans are still accepted and converted internally. .. versionchanged:: 0.4 If the *default* value is a callable, it will be called with the config object as its argument in order to get the default value. This can be used to implement config values whose default depends on other values. """ logger.debug('[app] adding config value: %r', (name, default, rebuild) + ((types,) if types else ())) # type: ignore if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.add(name, default, rebuild, types) def add_event(self, name): # type: (str) -> None """Register an event called *name*. This is needed to be able to emit it. """ logger.debug('[app] adding event: %r', name) self.events.add(name) def set_translator(self, name, translator_class, override=False): # type: (str, Type[nodes.NodeVisitor], bool) -> None """Register or override a Docutils translator class. This is used to register a custom output translator or to replace a builtin translator. This allows extensions to use custom translator and define custom nodes for the translator (see :meth:`add_node`). .. versionadded:: 1.3 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_translator(name, translator_class, override=override) def add_node(self, node, override=False, **kwds): # type: (Type[nodes.Element], bool, Any) -> None """Register a Docutils node class. This is necessary for Docutils internals. It may also be used in the future to validate nodes in the parsed documents. Node visitor functions for the Sphinx HTML, LaTeX, text and manpage writers can be given as keyword arguments: the keyword should be one or more of ``'html'``, ``'latex'``, ``'text'``, ``'man'``, ``'texinfo'`` or any other supported translators, the value a 2-tuple of ``(visit, depart)`` methods. ``depart`` can be ``None`` if the ``visit`` function raises :exc:`docutils.nodes.SkipNode`. Example: .. code-block:: python class math(docutils.nodes.Element): pass def visit_math_html(self, node): self.body.append(self.starttag(node, 'math')) def depart_math_html(self, node): self.body.append('</math>') app.add_node(math, html=(visit_math_html, depart_math_html)) Obviously, translators for which you don't specify visitor methods will choke on the node when encountered in a document to translate. .. versionchanged:: 0.5 Added the support for keyword arguments giving visit functions. """ logger.debug('[app] adding node: %r', (node, kwds)) if not override and docutils.is_node_registered(node): logger.warning(__('node class %r is already registered, ' 'its visitors will be overridden'), node.__name__, type='app', subtype='add_node') docutils.register_node(node) self.registry.add_translation_handlers(node, **kwds) def add_enumerable_node(self, node, figtype, title_getter=None, override=False, **kwds): # type: (Type[nodes.Element], str, TitleGetter, bool, Any) -> None """Register a Docutils node class as a numfig target. Sphinx numbers the node automatically. And then the users can refer it using :rst:role:`numref`. *figtype* is a type of enumerable nodes. Each figtypes have individual numbering sequences. As a system figtypes, ``figure``, ``table`` and ``code-block`` are defined. It is able to add custom nodes to these default figtypes. It is also able to define new custom figtype if new figtype is given. *title_getter* is a getter function to obtain the title of node. It takes an instance of the enumerable node, and it must return its title as string. The title is used to the default title of references for :rst:role:`ref`. By default, Sphinx searches ``docutils.nodes.caption`` or ``docutils.nodes.title`` from the node as a title. Other keyword arguments are used for node visitor functions. See the :meth:`.Sphinx.add_node` for details. .. versionadded:: 1.4 """ self.registry.add_enumerable_node(node, figtype, title_getter, override=override) self.add_node(node, override=override, **kwds) @property def enumerable_nodes(self): # type: () -> Dict[Type[nodes.Node], Tuple[str, TitleGetter]] warnings.warn('app.enumerable_nodes() is deprecated. ' 'Use app.get_domain("std").enumerable_nodes instead.', RemovedInSphinx30Warning, stacklevel=2) return self.registry.enumerable_nodes def add_directive(self, name, obj, content=None, arguments=None, override=False, **options): # NOQA # type: (str, Any, bool, Tuple[int, int, bool], bool, Any) -> None """Register a Docutils directive. *name* must be the prospective directive name. There are two possible ways to write a directive: - In the docutils 0.4 style, *obj* is the directive function. *content*, *arguments* and *options* are set as attributes on the function and determine whether the directive has content, arguments and options, respectively. **This style is deprecated.** - In the docutils 0.5 style, *obj* is the directive class. It must already have attributes named *has_content*, *required_arguments*, *optional_arguments*, *final_argument_whitespace* and *option_spec* that correspond to the options for the function way. See `the Docutils docs <http://docutils.sourceforge.net/docs/howto/rst-directives.html>`_ for details. The directive class must inherit from the class ``docutils.parsers.rst.Directive``. For example, the (already existing) :rst:dir:`literalinclude` directive would be added like this: .. code-block:: python from docutils.parsers.rst import Directive, directives class LiteralIncludeDirective(Directive): has_content = True required_arguments = 1 optional_arguments = 0 final_argument_whitespace = True option_spec = { 'class': directives.class_option, 'name': directives.unchanged, } def run(self): ... add_directive('literalinclude', LiteralIncludeDirective) .. versionchanged:: 0.6 Docutils 0.5-style directive classes are now supported. .. deprecated:: 1.8 Docutils 0.4-style (function based) directives support is deprecated. .. versionchanged:: 1.8 Add *override* keyword. """ logger.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) if not override and docutils.is_directive_registered(name): logger.warning(__('directive %r is already registered, it will be overridden'), name, type='app', subtype='add_directive') if not isclass(obj) or not issubclass(obj, Directive): directive = directive_helper(obj, content, arguments, **options) docutils.register_directive(name, directive) else: docutils.register_directive(name, obj) def add_role(self, name, role, override=False): # type: (str, Any, bool) -> None """Register a Docutils role. *name* must be the role name that occurs in the source, *role* the role function. Refer to the `Docutils documentation <http://docutils.sourceforge.net/docs/howto/rst-roles.html>`_ for more information. .. versionchanged:: 1.8 Add *override* keyword. """ logger.debug('[app] adding role: %r', (name, role)) if not override and docutils.is_role_registered(name): logger.warning(__('role %r is already registered, it will be overridden'), name, type='app', subtype='add_role') docutils.register_role(name, role) def add_generic_role(self, name, nodeclass, override=False): # type: (str, Any, bool) -> None """Register a generic Docutils role. Register a Docutils role that does nothing but wrap its contents in the node given by *nodeclass*. .. versionadded:: 0.6 .. versionchanged:: 1.8 Add *override* keyword. """ # Don't use ``roles.register_generic_role`` because it uses # ``register_canonical_role``. logger.debug('[app] adding generic role: %r', (name, nodeclass)) if not override and docutils.is_role_registered(name): logger.warning(__('role %r is already registered, it will be overridden'), name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) docutils.register_role(name, role) def add_domain(self, domain, override=False): # type: (Type[Domain], bool) -> None """Register a domain. Make the given *domain* (which must be a class; more precisely, a subclass of :class:`~sphinx.domains.Domain`) known to Sphinx. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_domain(domain, override=override) def override_domain(self, domain): # type: (Type[Domain]) -> None """Override a registered domain. Make the given *domain* class known to Sphinx, assuming that there is already a domain with its ``.name``. The new domain must be a subclass of the existing one. .. versionadded:: 1.0 .. deprecated:: 1.8 Integrated to :meth:`add_domain`. """ warnings.warn('app.override_domain() is deprecated. ' 'Use app.add_domain() with override option instead.', RemovedInSphinx30Warning, stacklevel=2) self.registry.add_domain(domain, override=True) def add_directive_to_domain(self, domain, name, obj, has_content=None, argument_spec=None, override=False, **option_spec): # type: (str, str, Any, bool, Any, bool, Any) -> None """Register a Docutils directive in a domain. Like :meth:`add_directive`, but the directive is added to the domain named *domain*. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_directive_to_domain(domain, name, obj, has_content, argument_spec, override=override, **option_spec) def add_role_to_domain(self, domain, name, role, override=False): # type: (str, str, Union[RoleFunction, XRefRole], bool) -> None """Register a Docutils role in a domain. Like :meth:`add_role`, but the role is added to the domain named *domain*. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_role_to_domain(domain, name, role, override=override) def add_index_to_domain(self, domain, index, override=False): # type: (str, Type[Index], bool) -> None """Register a custom index for a domain. Add a custom *index* class to the domain named *domain*. *index* must be a subclass of :class:`~sphinx.domains.Index`. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_index_to_domain(domain, index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[], override=False): # type: (str, str, str, Callable, Type[nodes.TextElement], str, List, bool) -> None """Register a new object type. This method is a very convenient way to add a new :term:`object` type that can be cross-referenced. It will do this: - Create a new directive (called *directivename*) for documenting an object. It will automatically add index entries if *indextemplate* is nonempty; if given, it must contain exactly one instance of ``%s``. See the example below for how the template will be interpreted. - Create a new role (called *rolename*) to cross-reference to these object descriptions. - If you provide *parse_node*, it must be a function that takes a string and a docutils node, and it must populate the node with children parsed from the string. It must then return the name of the item to be used in cross-referencing and index entries. See the :file:`conf.py` file in the source for this documentation for an example. - The *objname* (if not given, will default to *directivename*) names the type of object. It is used when listing objects, e.g. in search results. For example, if you have this call in a custom Sphinx extension:: app.add_object_type('directive', 'dir', 'pair: %s; directive') you can use this markup in your documents:: .. rst:directive:: function Document a function. <...> See also the :rst:dir:`function` directive. For the directive, an index entry will be generated as if you had prepended :: .. index:: pair: function; directive The reference node will be of class ``literal`` (so it will be rendered in a proportional font, as appropriate for code) unless you give the *ref_nodeclass* argument, which must be a docutils node class. Most useful are ``docutils.nodes.emphasis`` or ``docutils.nodes.strong`` -- you can also use ``docutils.nodes.generated`` if you want no further text decoration. If the text should be treated as literal (e.g. no smart quote replacement), but not have typewriter styling, use ``sphinx.addnodes.literal_emphasis`` or ``sphinx.addnodes.literal_strong``. For the role content, you have the same syntactical possibilities as for standard Sphinx roles (see :ref:`xref-syntax`). .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types, override=override) def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname='', override=False): # type: (str, str, str, Type[nodes.TextElement], str, bool) -> None """Register a new crossref object type. This method is very similar to :meth:`add_object_type` except that the directive it generates must be empty, and will produce no output. That means that you can add semantic targets to your sources, and refer to them using custom roles instead of generic ones (like :rst:role:`ref`). Example call:: app.add_crossref_type('topic', 'topic', 'single: %s', docutils.nodes.emphasis) Example usage:: .. topic:: application API The application API ------------------- Some random text here. See also :topic:`this section <application API>`. (Of course, the element following the ``topic`` directive needn't be a section.) .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_crossref_type(directivename, rolename, indextemplate, ref_nodeclass, objname, override=override) def add_transform(self, transform): # type: (Type[Transform]) -> None """Register a Docutils transform to be applied after parsing. Add the standard docutils :class:`Transform` subclass *transform* to the list of transforms that are applied after Sphinx parses a reST document. .. list-table:: priority range categories for Sphinx transforms :widths: 20,80 * - Priority - Main purpose in Sphinx * - 0-99 - Fix invalid nodes by docutils. Translate a doctree. * - 100-299 - Preparation * - 300-399 - early * - 400-699 - main * - 700-799 - Post processing. Deadline to modify text and referencing. * - 800-899 - Collect referencing and referenced nodes. Domain processing. * - 900-999 - Finalize and clean up. refs: `Transform Priority Range Categories`__ __ http://docutils.sourceforge.net/docs/ref/transforms.html#transform-priority-range-categories """ # NOQA self.registry.add_transform(transform) def add_post_transform(self, transform): # type: (Type[Transform]) -> None """Register a Docutils transform to be applied before writing. Add the standard docutils :class:`Transform` subclass *transform* to the list of transforms that are applied before Sphinx writes a document. """ self.registry.add_post_transform(transform) def add_javascript(self, filename, **kwargs): # type: (str, **str) -> None """An alias of :meth:`add_js_file`.""" warnings.warn('The app.add_javascript() is deprecated. ' 'Please use app.add_js_file() instead.', RemovedInSphinx40Warning, stacklevel=2) self.add_js_file(filename, **kwargs) def add_js_file(self, filename, **kwargs): # type: (str, **str) -> None """Register a JavaScript file to include in the HTML output. Add *filename* to the list of JavaScript files that the default HTML template will include. The filename must be relative to the HTML static path , or a full URI with scheme. The keyword arguments are also accepted for attributes of ``<script>`` tag. Example:: app.add_js_file('example.js') # => <script src="_static/example.js"></script> app.add_js_file('example.js', async="async") # => <script src="_static/example.js" async="async"></script> .. versionadded:: 0.5 .. versionchanged:: 1.8 Renamed from ``app.add_javascript()``. And it allows keyword arguments as attributes of script tag. """ self.registry.add_js_file(filename, **kwargs) if hasattr(self.builder, 'add_js_file'): self.builder.add_js_file(filename, **kwargs) # type: ignore def add_css_file(self, filename, **kwargs): # type: (str, **str) -> None """Register a stylesheet to include in the HTML output. Add *filename* to the list of CSS files that the default HTML template will include. The filename must be relative to the HTML static path, or a full URI with scheme. The keyword arguments are also accepted for attributes of ``<link>`` tag. Example:: app.add_css_file('custom.css') # => <link rel="stylesheet" href="_static/custom.css" type="text/css" /> app.add_css_file('print.css', media='print') # => <link rel="stylesheet" href="_static/print.css" # type="text/css" media="print" /> app.add_css_file('fancy.css', rel='alternate stylesheet', title='fancy') # => <link rel="alternate stylesheet" href="_static/fancy.css" # type="text/css" title="fancy" /> .. versionadded:: 1.0 .. versionchanged:: 1.6 Optional ``alternate`` and/or ``title`` attributes can be supplied with the *alternate* (of boolean type) and *title* (a string) arguments. The default is no title and *alternate* = ``False``. For more information, refer to the `documentation <https://mdn.io/Web/CSS/Alternative_style_sheets>`__. .. versionchanged:: 1.8 Renamed from ``app.add_stylesheet()``. And it allows keyword arguments as attributes of link tag. """ logger.debug('[app] adding stylesheet: %r', filename) self.registry.add_css_files(filename, **kwargs) if hasattr(self.builder, 'add_css_file'): self.builder.add_css_file(filename, **kwargs) # type: ignore def add_stylesheet(self, filename, alternate=False, title=None): # type: (str, bool, str) -> None """An alias of :meth:`add_css_file`.""" warnings.warn('The app.add_stylesheet() is deprecated. ' 'Please use app.add_css_file() instead.', RemovedInSphinx40Warning, stacklevel=2) attributes = {} # type: Dict[str, str] if alternate: attributes['rel'] = 'alternate stylesheet' else: attributes['rel'] = 'stylesheet' if title: attributes['title'] = title self.add_css_file(filename, **attributes) def add_latex_package(self, packagename, options=None): # type: (str, str) -> None r"""Register a package to include in the LaTeX source code. Add *packagename* to the list of packages that LaTeX source code will include. If you provide *options*, it will be taken to `\usepackage` declaration. .. code-block:: python app.add_latex_package('mypackage') # => \usepackage{mypackage} app.add_latex_package('mypackage', 'foo,bar') # => \usepackage[foo,bar]{mypackage} .. versionadded:: 1.3 """ self.registry.add_latex_package(packagename, options) def add_lexer(self, alias, lexer): # type: (str, Any) -> None """Register a new lexer for source code. Use *lexer*, which must be an instance of a Pygments lexer class, to highlight code blocks with the given language *alias*. .. versionadded:: 0.6 """ logger.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): # type: (Any) -> None """Register a new documenter class for the autodoc extension. Add *cls* as a new documenter class for the :mod:`sphinx.ext.autodoc` extension. It must be a subclass of :class:`sphinx.ext.autodoc.Documenter`. This allows to auto-document new types of objects. See the source of the autodoc module for examples on how to subclass :class:`Documenter`. .. todo:: Add real docs for Documenter and subclassing .. versionadded:: 0.6 """ logger.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext.autodoc.directive import AutodocDirective self.registry.add_documenter(cls.objtype, cls) self.add_directive('auto' + cls.objtype, AutodocDirective) def add_autodoc_attrgetter(self, typ, getter): # type: (Type, Callable[[Any, str, Any], Any]) -> None """Register a new ``getattr``-like function for the autodoc extension. Add *getter*, which must be a function with an interface compatible to the :func:`getattr` builtin, as the autodoc attribute getter for objects that are instances of *typ*. All cases where autodoc needs to get an attribute of a type are then handled by this function instead of :func:`getattr`. .. versionadded:: 0.6 """ logger.debug('[app] adding autodoc attrgetter: %r', (typ, getter)) self.registry.add_autodoc_attrgetter(typ, getter) def add_search_language(self, cls): # type: (Any) -> None """Register a new language for the HTML search index. Add *cls*, which must be a subclass of :class:`sphinx.search.SearchLanguage`, as a support language for building the HTML full-text search index. The class must have a *lang* attribute that indicates the language it should be used for. See :confval:`html_search_language`. .. versionadded:: 1.1 """ logger.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_suffix(self, suffix, filetype, override=False): # type: (str, str, bool) -> None """Register a suffix of source files. Same as :confval:`source_suffix`. The users can override this using the setting. .. versionadded:: 1.8 """ self.registry.add_source_suffix(suffix, filetype, override=override) def add_source_parser(self, *args, **kwargs): # type: (Any, Any) -> None """Register a parser class. .. versionadded:: 1.4 .. versionchanged:: 1.8 *suffix* argument is deprecated. It only accepts *parser* argument. Use :meth:`add_source_suffix` API to register suffix instead. .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_source_parser(*args, **kwargs) def add_env_collector(self, collector): # type: (Type[EnvironmentCollector]) -> None """Register an environment collector class. Refer to :ref:`collector-api`. .. versionadded:: 1.6 """ logger.debug('[app] adding environment collector: %r', collector) collector().enable(self) def add_html_theme(self, name, theme_path): # type: (str, str) -> None """Register a HTML Theme. The *name* is a name of theme, and *path* is a full path to the theme (refs: :ref:`distribute-your-theme`). .. versionadded:: 1.6 """ logger.debug('[app] adding HTML theme: %r, %r', name, theme_path) self.html_themes[name] = theme_path def add_html_math_renderer(self, name, inline_renderers=None, block_renderers=None): # type: (str, Tuple[Callable, Callable], Tuple[Callable, Callable]) -> None """Register a math renderer for HTML. The *name* is a name of math renderer. Both *inline_renderers* and *block_renderers* are used as visitor functions for the HTML writer: the former for inline math node (``nodes.math``), the latter for block math node (``nodes.math_block``). Regarding visitor functions, see :meth:`add_node` for details. .. versionadded:: 1.8 """ self.registry.add_html_math_renderer(name, inline_renderers, block_renderers) def add_message_catalog(self, catalog, locale_dir): # type: (str, str) -> None """Register a message catalog. The *catalog* is a name of catalog, and *locale_dir* is a base path of message catalog. For more details, see :func:`sphinx.locale.get_translation()`. .. versionadded:: 1.8 """ locale.init([locale_dir], self.config.language, catalog) locale.init_console(locale_dir, catalog) # ---- other methods ------------------------------------------------- def is_parallel_allowed(self, typ): # type: (str) -> bool """Check parallel processing is allowed or not. ``typ`` is a type of processing; ``'read'`` or ``'write'``. """ if typ == 'read': attrname = 'parallel_read_safe' message = __("the %s extension does not declare if it is safe " "for parallel reading, assuming it isn't - please " "ask the extension author to check and make it " "explicit") elif typ == 'write': attrname = 'parallel_write_safe' message = __("the %s extension does not declare if it is safe " "for parallel writing, assuming it isn't - please " "ask the extension author to check and make it " "explicit") else: raise ValueError('parallel type %s is not supported' % typ) for ext in self.extensions.values(): allowed = getattr(ext, attrname, None) if allowed is None: logger.warning(message, ext.name) logger.warning(__('doing serial %s'), typ) return False elif not allowed: return False return True @property def _setting_up_extension(self): # type: () -> List[str] warnings.warn('app._setting_up_extension is deprecated.', RemovedInSphinx30Warning) return ['?']
def assign_figure_numbers(self, env: BuildEnvironment) -> List[str]: """Assign a figure number to each figure under a numbered toctree.""" rewrite_needed = [] assigned = set() # type: Set[str] old_fignumbers = env.toc_fignumbers env.toc_fignumbers = {} fignum_counter = {} # type: Dict[str, Dict[Tuple[int, ...], int]] def get_figtype(node: Node) -> str: for domain in env.domains.values(): figtype = domain.get_enumerable_node_type(node) if figtype: return figtype return None def get_section_number(docname: str, section: nodes.section) -> Tuple[int, ...]: anchorname = '#' + section['ids'][0] secnumbers = env.toc_secnumbers.get(docname, {}) if anchorname in secnumbers: secnum = secnumbers.get(anchorname) else: secnum = secnumbers.get('') return secnum or tuple() def get_next_fignumber(figtype: str, secnum: Tuple[int, ...]) -> Tuple[int, ...]: counter = fignum_counter.setdefault(figtype, {}) secnum = secnum[:env.config.numfig_secnum_depth] counter[secnum] = counter.get(secnum, 0) + 1 return secnum + (counter[secnum],) def register_fignumber(docname: str, secnum: Tuple[int, ...], figtype: str, fignode: Element) -> None: env.toc_fignumbers.setdefault(docname, {}) fignumbers = env.toc_fignumbers[docname].setdefault(figtype, {}) figure_id = fignode['ids'][0] fignumbers[figure_id] = get_next_fignumber(figtype, secnum) def _walk_doctree(docname: str, doctree: Element, secnum: Tuple[int, ...]) -> None: for subnode in doctree.children: if isinstance(subnode, nodes.section): next_secnum = get_section_number(docname, subnode) if next_secnum: _walk_doctree(docname, subnode, next_secnum) else: _walk_doctree(docname, subnode, secnum) elif isinstance(subnode, addnodes.toctree): for title, subdocname in subnode['entries']: if url_re.match(subdocname) or subdocname == 'self': # don't mess with those continue _walk_doc(subdocname, secnum) elif isinstance(subnode, nodes.Element): figtype = get_figtype(subnode) if figtype and subnode['ids']: register_fignumber(docname, secnum, figtype, subnode) _walk_doctree(docname, subnode, secnum) def _walk_doc(docname: str, secnum: Tuple[int, ...]) -> None: if docname not in assigned: assigned.add(docname) doctree = env.get_doctree(docname) _walk_doctree(docname, doctree, secnum) if env.config.numfig: _walk_doc(env.config.master_doc, tuple()) for docname, fignums in env.toc_fignumbers.items(): if fignums != old_fignumbers.get(docname): rewrite_needed.append(docname) return rewrite_needed
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} self._extension_metadata = {} self._listeners = {} self.domains = BUILTIN_DOMAINS.copy() self.buildername = buildername self.builderclasses = BUILTIN_BUILDERS.copy() self.builder = None self.env = None self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() self._translators = {} # keep last few messages for traceback self.messagelog = deque(maxlen=10) # say hello to the world self.info(bold('Running Sphinx v%s' % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): self.info('making output directory...') os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # defer checking types until i18n has been initialized # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # extension loading support for alabaster theme # self.config.html_theme is not set from conf.py at here # for now, sphinx always load a 'alabaster' extension. if 'alabaster' not in self.config.extensions: self.config.extensions.append('alabaster') # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, '__call__'): self.config.setup(self) else: raise ConfigError( "'setup' that is specified in the conf.py has not been " + "callable. Please provide a callable `setup` function " + "in order to behave as a sphinx extension conf.py itself.") # now that we know all config values, collect them from conf.py self.config.init_values(self.warn) # check the Sphinx version if requested if self.config.needs_sphinx and \ self.config.needs_sphinx > sphinx.__display_version__[:3]: raise VersionRequirementError( 'This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.' % self.config.needs_sphinx) # check extension versions if requested if self.config.needs_extensions: for extname, needs_ver in self.config.needs_extensions.items(): if extname not in self._extensions: self.warn( 'needs_extensions config value specifies a ' 'version requirement for extension %s, but it is ' 'not loaded' % extname) continue has_ver = self._extension_metadata[extname]['version'] if has_ver == 'unknown version' or needs_ver > has_ver: raise VersionRequirementError( 'This project needs the extension %s at least in ' 'version %s and therefore cannot be built with the ' 'loaded version (%s).' % (extname, needs_ver, has_ver)) # set up translation infrastructure self._init_i18n() # check all configuration values for permissible types self.config.check_types(self.warn) # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(self.buildername) def _init_i18n(self): """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) locale_dirs = [None, path.join(package_dir, 'locale')] + \ [path.join(self.srcdir, x) for x in self.config.locale_dirs] else: locale_dirs = [] self.translator, has_translation = locale.init( locale_dirs, self.config.language, charset=self.config.source_encoding) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated self.info('done') else: self.info('not available for built-in messages') def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle( self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn) def _init_builder(self, buildername): if buildername is None: print('No builder selected, using default: html', file=self._status) buildername = 'html' if buildername not in self.builderclasses: raise SphinxError('Builder name %s not registered' % buildername) builderclass = self.builderclasses[buildername] if isinstance(builderclass, tuple): # builtin builder mod, cls = builderclass builderclass = getattr( __import__('sphinx.builders.' + mod, None, None, [cls]), cls) self.builder = builderclass(self) self.emit('builder-inited') # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = (self.statuscode == 0 and 'succeeded' or 'finished with problems') if self._warncount: self.info( bold('build %s, %s warning%s.' % (status, self._warncount, self._warncount != 1 and 's' or ''))) else: self.info(bold('build %s.' % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def _log(self, message, wfile, nonl=False): try: wfile.write(message) except UnicodeEncodeError: encoding = getattr(wfile, 'encoding', 'ascii') or 'ascii' wfile.write(message.encode(encoding, 'replace')) if not nonl: wfile.write('\n') if hasattr(wfile, 'flush'): wfile.flush() self.messagelog.append(message) def warn(self, message, location=None, prefix='WARNING: '): """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if isinstance(location, tuple): docname, lineno = location if docname: location = '%s:%s' % (self.env.doc2path(docname), lineno or '') else: location = None warntext = location and '%s: %s%s\n' % (location, prefix, message) or \ '%s%s\n' % (prefix, message) if self.warningiserror: raise SphinxWarning(warntext) self._warncount += 1 self._log(warntext, self._warning, True) def info(self, message='', nonl=False): """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ self._log(message, self._status, nonl) def verbose(self, message, *args, **kwargs): """Emit a verbose informational message. The message will only be emitted for verbosity levels >= 1 (i.e. at least one ``-v`` option was given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 1: return if args or kwargs: message = message % (args or kwargs) self._log(message, self._status) def debug(self, message, *args, **kwargs): """Emit a debug-level informational message. The message will only be emitted for verbosity levels >= 2 (i.e. at least two ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 2: return if args or kwargs: message = message % (args or kwargs) self._log(darkgray(message), self._status) def debug2(self, message, *args, **kwargs): """Emit a lowlevel debug-level informational message. The message will only be emitted for verbosity level 3 (i.e. three ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 3: return if args or kwargs: message = message % (args or kwargs) self._log(lightgray(message), self._status) def _display_chunk(chunk): if isinstance(chunk, (list, tuple)): if len(chunk) == 1: return text_type(chunk[0]) return '%s .. %s' % (chunk[0], chunk[-1]) return text_type(chunk) def old_status_iterator(self, iterable, summary, colorfunc=darkgreen, stringify_func=_display_chunk): l = 0 for item in iterable: if l == 0: self.info(bold(summary), nonl=1) l = 1 self.info(colorfunc(stringify_func(item)) + ' ', nonl=1) yield item if l == 1: self.info() # new version with progress info def status_iterator(self, iterable, summary, colorfunc=darkgreen, length=0, stringify_func=_display_chunk): if length == 0: for item in self.old_status_iterator(iterable, summary, colorfunc, stringify_func): yield item return l = 0 summary = bold(summary) for item in iterable: l += 1 s = '%s[%3d%%] %s' % (summary, 100 * l / length, colorfunc(stringify_func(item))) if self.verbosity: s += '\n' else: s = term_width_line(s) self.info(s, nonl=1) yield item if l > 0: self.info() # ---- general extensibility interface ------------------------------------- def setup_extension(self, extension): """Import and setup a Sphinx extension module. No-op if called twice.""" self.debug('[app] setting up extension: %r', extension) if extension in self._extensions: return try: mod = __import__(extension, None, None, ['setup']) except ImportError as err: self.verbose('Original exception:\n' + traceback.format_exc()) raise ExtensionError('Could not import extension %s' % extension, err) if not hasattr(mod, 'setup'): self.warn('extension %r has no setup() function; is it really ' 'a Sphinx extension module?' % extension) ext_meta = None else: try: ext_meta = mod.setup(self) except VersionRequirementError as err: # add the extension name to the version required raise VersionRequirementError( 'The %s extension used by this project needs at least ' 'Sphinx v%s; it therefore cannot be built with this ' 'version.' % (extension, err)) if ext_meta is None: ext_meta = {} # special-case for compatibility if extension == 'rst2pdf.pdfbuilder': ext_meta = {'parallel_read_safe': True} try: if not ext_meta.get('version'): ext_meta['version'] = 'unknown version' except Exception: self.warn('extension %r returned an unsupported object from ' 'its setup() function; it should return None or a ' 'metadata dictionary' % extension) ext_meta = {'version': 'unknown version'} self._extensions[extension] = mod self._extension_metadata[extension] = ext_meta def require_sphinx(self, version): # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def _validate_event(self, event): event = intern(event) if event not in self._events: raise ExtensionError('Unknown event name: %s' % event) def connect(self, event, callback): self._validate_event(event) listener_id = self.next_listener_id if event not in self._listeners: self._listeners[event] = {listener_id: callback} else: self._listeners[event][listener_id] = callback self.next_listener_id += 1 self.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): self.debug('[app] disconnecting event: [id=%s]', listener_id) for event in itervalues(self._listeners): event.pop(listener_id, None) def emit(self, event, *args): try: self.debug2('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass results = [] if event in self._listeners: for _, callback in iteritems(self._listeners[event]): results.append(callback(self, *args)) return results def emit_firstresult(self, event, *args): for result in self.emit(event, *args): if result is not None: return result return None # registering addon parts def add_builder(self, builder): self.debug('[app] adding builder: %r', builder) if not hasattr(builder, 'name'): raise ExtensionError('Builder class %s has no "name" attribute' % builder) if builder.name in self.builderclasses: if isinstance(self.builderclasses[builder.name], tuple): raise ExtensionError('Builder %r is a builtin builder' % builder.name) else: raise ExtensionError( 'Builder %r already exists (in module %s)' % (builder.name, self.builderclasses[builder.name].__module__)) self.builderclasses[builder.name] = builder def add_config_value(self, name, default, rebuild): self.debug('[app] adding config value: %r', (name, default, rebuild)) if name in self.config.values: raise ExtensionError('Config value %r already present' % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.values[name] = (default, rebuild) def add_event(self, name): self.debug('[app] adding event: %r', name) if name in self._events: raise ExtensionError('Event %r already present' % name) self._events[name] = '' def set_translator(self, name, translator_class): self.info(bold('A Translator for the %s builder is changed.' % name)) self._translators[name] = translator_class def add_node(self, node, **kwds): self.debug('[app] adding node: %r', (node, kwds)) nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError('Value for key %r must be a ' '(visit, depart) function tuple' % key) translator = self._translators.get(key) if translator is not None: pass elif key == 'html': from sphinx.writers.html import HTMLTranslator as translator elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator as translator elif key == 'text': from sphinx.writers.text import TextTranslator as translator elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator \ as translator elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator \ as translator else: # ignore invalid keys for compatibility continue setattr(translator, 'visit_' + node.__name__, visit) if depart: setattr(translator, 'depart_' + node.__name__, depart) def _directive_helper(self, obj, content=None, arguments=None, **options): if isinstance(obj, (types.FunctionType, types.MethodType)): obj.content = content obj.arguments = arguments or (0, 0, False) obj.options = options return convert_directive_function(obj) else: if content or arguments or options: raise ExtensionError('when adding directive classes, no ' 'additional arguments may be given') return obj def add_directive(self, name, obj, content=None, arguments=None, **options): self.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) directives.register_directive( name, self._directive_helper(obj, content, arguments, **options)) def add_role(self, name, role): self.debug('[app] adding role: %r', (name, role)) roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # don't use roles.register_generic_role because it uses # register_canonical_role self.debug('[app] adding generic role: %r', (name, nodeclass)) role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): self.debug('[app] adding domain: %r', domain) if domain.name in self.domains: raise ExtensionError('domain %s already registered' % domain.name) self.domains[domain.name] = domain def override_domain(self, domain): self.debug('[app] overriding domain: %r', domain) if domain.name not in self.domains: raise ExtensionError('domain %s not yet registered' % domain.name) if not issubclass(domain, self.domains[domain.name]): raise ExtensionError('new domain not a subclass of registered %s ' 'domain' % domain.name) self.domains[domain.name] = domain def add_directive_to_domain(self, domain, name, obj, content=None, arguments=None, **options): self.debug('[app] adding directive to domain: %r', (domain, name, obj, content, arguments, options)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].directives[name] = \ self._directive_helper(obj, content, arguments, **options) def add_role_to_domain(self, domain, name, role): self.debug('[app] adding role to domain: %r', (domain, name, role)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].roles[name] = role def add_index_to_domain(self, domain, index): self.debug('[app] adding index to domain: %r', (domain, index)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].indices.append(index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): self.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of GenericObject as the new directive new_directive = type( directivename, (GenericObject, object), { 'indextemplate': indextemplate, 'parse_node': staticmethod(parse_node), 'doc_field_types': doc_field_types }) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) # backwards compatible alias add_description_unit = add_object_type def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): self.debug( '[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of Target as the new directive new_directive = type(directivename, (Target, object), {'indextemplate': indextemplate}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) def add_transform(self, transform): self.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_javascript(self, filename): self.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename): self.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.css_files.append(filename) else: StandaloneHTMLBuilder.css_files.append( posixpath.join('_static', filename)) def add_latex_package(self, packagename, options=None): self.debug('[app] adding latex package: %r', packagename) from sphinx.builders.latex import LaTeXBuilder LaTeXBuilder.usepackages.append((packagename, options)) def add_lexer(self, alias, lexer): self.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): self.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): self.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): self.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): # type: (unicode, unicode, unicode, unicode, unicode, Dict, IO, IO, bool, bool, List[unicode], int, int) -> None # NOQA self.verbosity = verbosity self._extensions = {} # type: Dict[unicode, Any] self._extension_metadata = {} # type: Dict[unicode, Dict[unicode, Any]] self._additional_source_parsers = {} # type: Dict[unicode, Parser] self._setting_up_extension = ['?'] # type: List[unicode] self.domains = {} # type: Dict[unicode, Type[Domain]] self.buildername = buildername self.builderclasses = {} # type: Dict[unicode, Type[Builder]] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.enumerable_nodes = {} # type: Dict[nodes.Node, Tuple[unicode, Callable]] # NOQA self.post_transforms = [] # type: List[Transform] self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() # type: IO else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror logging.setup(self, self._status, self._warning) self.events = EventManager() self._translators = {} # type: Dict[unicode, nodes.GenericNodeVisitor] # keep last few messages for traceback self.messagelog = deque(maxlen=10) # type: deque # say hello to the world logger.info(bold('Running Sphinx v%s' % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): logger.info('making output directory...') os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode() # defer checking types until i18n has been initialized # initialize some limited config variables before initialize i18n and loading # extensions self.config.pre_init_values() # set up translation infrastructure self._init_i18n() # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( _('This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.') % self.config.needs_sphinx) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # extension loading support for alabaster theme # self.config.html_theme is not set from conf.py at here # for now, sphinx always load a 'alabaster' extension. if 'alabaster' not in self.config.extensions: self.config.extensions.append('alabaster') # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: self._setting_up_extension = ['conf.py'] # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, '__call__'): self.config.setup(self) else: raise ConfigError( _("'setup' that is specified in the conf.py has not been " "callable. Please provide a callable `setup` function " "in order to behave as a sphinx extension conf.py itself.") ) # now that we know all config values, collect them from conf.py self.config.init_values() # check extension versions if requested if self.config.needs_extensions: for extname, needs_ver in self.config.needs_extensions.items(): if extname not in self._extensions: logger.warning(_('needs_extensions config value specifies a ' 'version requirement for extension %s, but it is ' 'not loaded'), extname) continue has_ver = self._extension_metadata[extname]['version'] if has_ver == 'unknown version' or needs_ver > has_ver: raise VersionRequirementError( _('This project needs the extension %s at least in ' 'version %s and therefore cannot be built with the ' 'loaded version (%s).') % (extname, needs_ver, has_ver)) # check primary_domain if requested if self.config.primary_domain and self.config.primary_domain not in self.domains: logger.warning(_('primary_domain %r not found, ignored.'), self.config.primary_domain) # check all configuration values for permissible types self.config.check_types() # set up source_parsers self._init_source_parsers() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(self.buildername) # set up the enumerable nodes self._init_enumerable_nodes() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: logger.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) user_locale_dirs = [ path.join(self.srcdir, x) for x in self.config.locale_dirs] # compile mo files if sphinx.po file in user locale directories are updated for catinfo in find_catalog_source_files( user_locale_dirs, self.config.language, domains=['sphinx'], charset=self.config.source_encoding): catinfo.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale')] + user_locale_dirs else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated logger.info(_('done')) else: logger.info('not available for built-in messages') def _init_source_parsers(self): # type: () -> None for suffix, parser in iteritems(self._additional_source_parsers): if suffix not in self.config.source_suffix: self.config.source_suffix.append(suffix) if suffix not in self.config.source_parsers: self.config.source_parsers[suffix] = parser def _init_env(self, freshenv): # type: (bool) -> None if freshenv: self.env = BuildEnvironment(self) self.env.find_files(self.config, self.buildername) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: logger.info(bold(_('loading pickled environment... ')), nonl=True) filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) self.env = BuildEnvironment.frompickle(filename, self) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) logger.info(_('done')) except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: logger.info(_('not yet created')) else: logger.info(_('failed: %s'), err) self._init_env(freshenv=True) def _init_builder(self, buildername): # type: (unicode) -> None if buildername is None: logger.info(_('No builder selected, using default: html')) buildername = 'html' if buildername not in self.builderclasses: raise SphinxError(_('Builder name %s not registered') % buildername) builderclass = self.builderclasses[buildername] self.builder = builderclass(self) self.emit('builder-inited') def _init_enumerable_nodes(self): # type: () -> None for node, settings in iteritems(self.enumerable_nodes): self.env.get_domain('std').enumerable_nodes[node] = settings # type: ignore # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[unicode]) -> None try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = (self.statuscode == 0 and _('succeeded') or _('finished with problems')) if self._warncount: logger.info(bold(_('build %s, %s warning%s.') % (status, self._warncount, self._warncount != 1 and 's' or ''))) else: logger.info(bold(_('build %s.') % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def warn(self, message, location=None, prefix=None, type=None, subtype=None, colorfunc=None): # type: (unicode, unicode, unicode, unicode, unicode, Callable) -> None """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. *type* and *subtype* are used to suppress warnings with :confval:`suppress_warnings`. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if prefix: warnings.warn('prefix option of warn() is now deprecated.', RemovedInSphinx17Warning) if colorfunc: warnings.warn('colorfunc option of warn() is now deprecated.', RemovedInSphinx17Warning) warnings.warn('app.warning() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.warning(message, type=type, subtype=subtype, location=location) def info(self, message='', nonl=False): # type: (unicode, bool) -> None """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ warnings.warn('app.info() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.info(message, nonl=nonl) def verbose(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a verbose informational message.""" warnings.warn('app.verbose() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.verbose(message, *args, **kwargs) def debug(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a debug-level informational message.""" warnings.warn('app.debug() is now deprecated. Use sphinx.util.logging instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) def debug2(self, message, *args, **kwargs): # type: (unicode, Any, Any) -> None """Emit a lowlevel debug-level informational message.""" warnings.warn('app.debug2() is now deprecated. Use debug() instead.', RemovedInSphinx20Warning) logger.debug(message, *args, **kwargs) def _display_chunk(chunk): # type: (Any) -> unicode warnings.warn('app._display_chunk() is now deprecated. ' 'Use sphinx.util.display_chunk() instead.', RemovedInSphinx17Warning) return display_chunk(chunk) def old_status_iterator(self, iterable, summary, colorfunc=darkgreen, stringify_func=display_chunk): # type: (Iterable, unicode, Callable, Callable[[Any], unicode]) -> Iterator warnings.warn('app.old_status_iterator() is now deprecated. ' 'Use sphinx.util.status_iterator() instead.', RemovedInSphinx17Warning) for item in old_status_iterator(iterable, summary, color="darkgreen", stringify_func=stringify_func): yield item # new version with progress info def status_iterator(self, iterable, summary, colorfunc=darkgreen, length=0, stringify_func=_display_chunk): # type: (Iterable, unicode, Callable, int, Callable[[Any], unicode]) -> Iterable warnings.warn('app.status_iterator() is now deprecated. ' 'Use sphinx.util.status_iterator() instead.', RemovedInSphinx17Warning) for item in status_iterator(iterable, summary, length=length, verbosity=self.verbosity, color="darkgreen", stringify_func=stringify_func): yield item # ---- general extensibility interface ------------------------------------- def setup_extension(self, extension): # type: (unicode) -> None """Import and setup a Sphinx extension module. No-op if called twice.""" logger.debug('[app] setting up extension: %r', extension) if extension in self._extensions: return if extension in EXTENSION_BLACKLIST: logger.warning(_('the extension %r was already merged with Sphinx since ' 'version %s; this extension is ignored.'), extension, EXTENSION_BLACKLIST[extension]) return self._setting_up_extension.append(extension) try: mod = __import__(extension, None, None, ['setup']) except ImportError as err: logger.verbose(_('Original exception:\n') + traceback.format_exc()) raise ExtensionError(_('Could not import extension %s') % extension, err) if not hasattr(mod, 'setup'): logger.warning(_('extension %r has no setup() function; is it really ' 'a Sphinx extension module?'), extension) ext_meta = None else: try: ext_meta = mod.setup(self) except VersionRequirementError as err: # add the extension name to the version required raise VersionRequirementError( _('The %s extension used by this project needs at least ' 'Sphinx v%s; it therefore cannot be built with this ' 'version.') % (extension, err)) if ext_meta is None: ext_meta = {} # special-case for compatibility if extension == 'rst2pdf.pdfbuilder': ext_meta = {'parallel_read_safe': True} try: if not ext_meta.get('version'): ext_meta['version'] = 'unknown version' except Exception: logger.warning(_('extension %r returned an unsupported object from ' 'its setup() function; it should return None or a ' 'metadata dictionary'), extension) ext_meta = {'version': 'unknown version'} self._extensions[extension] = mod self._extension_metadata[extension] = ext_meta self._setting_up_extension.pop() def require_sphinx(self, version): # type: (unicode) -> None # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): # type: (str, unicode) -> Any """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def connect(self, event, callback): # type: (unicode, Callable) -> int listener_id = self.events.connect(event, callback) logger.debug('[app] connecting event %r: %r', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None logger.debug('[app] disconnecting event: [id=%s]', listener_id) self.events.disconnect(listener_id) def emit(self, event, *args): # type: (unicode, Any) -> List try: logger.debug('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass return self.events.emit(event, self, *args) def emit_firstresult(self, event, *args): # type: (unicode, Any) -> Any return self.events.emit_firstresult(event, self, *args) # registering addon parts def add_builder(self, builder): # type: (Type[Builder]) -> None logger.debug('[app] adding builder: %r', builder) if not hasattr(builder, 'name'): raise ExtensionError(_('Builder class %s has no "name" attribute') % builder) if builder.name in self.builderclasses: raise ExtensionError(_('Builder %r already exists (in module %s)') % (builder.name, self.builderclasses[builder.name].__module__)) self.builderclasses[builder.name] = builder def add_config_value(self, name, default, rebuild, types=()): # type: (unicode, Any, Union[bool, unicode], Any) -> None logger.debug('[app] adding config value: %r', (name, default, rebuild) + ((types,) if types else ())) # type: ignore if name in self.config: raise ExtensionError(_('Config value %r already present') % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.add(name, default, rebuild, types) def add_event(self, name): # type: (unicode) -> None logger.debug('[app] adding event: %r', name) self.events.add(name) def set_translator(self, name, translator_class): # type: (unicode, Any) -> None logger.info(bold(_('A Translator for the %s builder is changed.') % name)) self._translators[name] = translator_class def add_node(self, node, **kwds): # type: (nodes.Node, Any) -> None logger.debug('[app] adding node: %r', (node, kwds)) if not kwds.pop('override', False) and \ hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__): logger.warning(_('while setting up extension %s: node class %r is ' 'already registered, its visitors will be overridden'), self._setting_up_extension, node.__name__, type='app', subtype='add_node') nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError(_('Value for key %r must be a ' '(visit, depart) function tuple') % key) translator = self._translators.get(key) translators = [] if translator is not None: translators.append(translator) elif key == 'html': from sphinx.writers.html import HTMLTranslator translators.append(HTMLTranslator) if is_html5_writer_available(): from sphinx.writers.html5 import HTML5Translator translators.append(HTML5Translator) elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator translators.append(LaTeXTranslator) elif key == 'text': from sphinx.writers.text import TextTranslator translators.append(TextTranslator) elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator translators.append(ManualPageTranslator) elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator translators.append(TexinfoTranslator) for translator in translators: setattr(translator, 'visit_' + node.__name__, visit) if depart: setattr(translator, 'depart_' + node.__name__, depart) def add_enumerable_node(self, node, figtype, title_getter=None, **kwds): # type: (nodes.Node, unicode, Callable, Any) -> None self.enumerable_nodes[node] = (figtype, title_getter) self.add_node(node, **kwds) def _directive_helper(self, obj, content=None, arguments=None, **options): # type: (Any, unicode, Any, Any) -> Any if isinstance(obj, (types.FunctionType, types.MethodType)): obj.content = content # type: ignore obj.arguments = arguments or (0, 0, False) # type: ignore obj.options = options # type: ignore return convert_directive_function(obj) else: if content or arguments or options: raise ExtensionError(_('when adding directive classes, no ' 'additional arguments may be given')) return obj def add_directive(self, name, obj, content=None, arguments=None, **options): # type: (unicode, Any, unicode, Any, Any) -> None logger.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) if name in directives._directives: logger.warning(_('while setting up extension %s: directive %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_directive') directives.register_directive( name, self._directive_helper(obj, content, arguments, **options)) def add_role(self, name, role): # type: (unicode, Any) -> None logger.debug('[app] adding role: %r', (name, role)) if name in roles._roles: logger.warning(_('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_role') roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # type: (unicode, Any) -> None # don't use roles.register_generic_role because it uses # register_canonical_role logger.debug('[app] adding generic role: %r', (name, nodeclass)) if name in roles._roles: logger.warning(_('while setting up extension %s: role %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] adding domain: %r', domain) if domain.name in self.domains: raise ExtensionError(_('domain %s already registered') % domain.name) self.domains[domain.name] = domain def override_domain(self, domain): # type: (Type[Domain]) -> None logger.debug('[app] overriding domain: %r', domain) if domain.name not in self.domains: raise ExtensionError(_('domain %s not yet registered') % domain.name) if not issubclass(domain, self.domains[domain.name]): raise ExtensionError(_('new domain not a subclass of registered %s ' 'domain') % domain.name) self.domains[domain.name] = domain def add_directive_to_domain(self, domain, name, obj, content=None, arguments=None, **options): # type: (unicode, unicode, Any, unicode, Any, Any) -> None logger.debug('[app] adding directive to domain: %r', (domain, name, obj, content, arguments, options)) if domain not in self.domains: raise ExtensionError(_('domain %s not yet registered') % domain) self.domains[domain].directives[name] = \ self._directive_helper(obj, content, arguments, **options) def add_role_to_domain(self, domain, name, role): # type: (unicode, unicode, Any) -> None logger.debug('[app] adding role to domain: %r', (domain, name, role)) if domain not in self.domains: raise ExtensionError(_('domain %s not yet registered') % domain) self.domains[domain].roles[name] = role def add_index_to_domain(self, domain, index): # type: (unicode, Type[Index]) -> None logger.debug('[app] adding index to domain: %r', (domain, index)) if domain not in self.domains: raise ExtensionError(_('domain %s not yet registered') % domain) self.domains[domain].indices.append(index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): # type: (unicode, unicode, unicode, Callable, nodes.Node, unicode, List) -> None logger.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of GenericObject as the new directive new_directive = type(directivename, (GenericObject, object), # type: ignore {'indextemplate': indextemplate, 'parse_node': staticmethod(parse_node), # type: ignore 'doc_field_types': doc_field_types}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) # backwards compatible alias add_description_unit = add_object_type def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): # type: (unicode, unicode, unicode, nodes.Node, unicode) -> None logger.debug('[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of Target as the new directive new_directive = type(directivename, (Target, object), # type: ignore {'indextemplate': indextemplate}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) def add_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_post_transform(self, transform): # type: (Type[Transform]) -> None logger.debug('[app] adding post transform: %r', transform) self.post_transforms.append(transform) def add_javascript(self, filename): # type: (unicode) -> None logger.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename): # type: (unicode) -> None logger.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.css_files.append(filename) else: StandaloneHTMLBuilder.css_files.append( posixpath.join('_static', filename)) def add_latex_package(self, packagename, options=None): # type: (unicode, unicode) -> None logger.debug('[app] adding latex package: %r', packagename) if hasattr(self.builder, 'usepackages'): # only for LaTeX builder self.builder.usepackages.append((packagename, options)) # type: ignore def add_lexer(self, alias, lexer): # type: (unicode, Any) -> None logger.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): # type: (Any) -> None logger.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): # type: (Any, Callable) -> None logger.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): # type: (Any) -> None logger.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_parser(self, suffix, parser): # type: (unicode, Parser) -> None logger.debug('[app] adding search source_parser: %r, %r', suffix, parser) if suffix in self._additional_source_parsers: logger.warning(_('while setting up extension %s: source_parser for %r is ' 'already registered, it will be overridden'), self._setting_up_extension[-1], suffix, type='app', subtype='add_source_parser') self._additional_source_parsers[suffix] = parser def add_env_collector(self, collector): # type: (Type[EnvironmentCollector]) -> None logger.debug('[app] adding environment collector: %r', collector) collector().enable(self)
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} self._listeners = {} self.domains = BUILTIN_DOMAINS.copy() self.builderclasses = BUILTIN_BUILDERS.copy() self.builder = None self.env = None self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = StringIO() self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = StringIO() else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() # say hello to the world self.info(bold('Running Sphinx v%s' % sphinx.__version__)) # status code for command-line application self.statuscode = 0 # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # backwards compatibility: activate old C markup self.setup_extension('sphinx.ext.oldcmarkup') # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: self.config.setup(self) # now that we know all config values, collect them from conf.py self.config.init_values() # check the Sphinx version if requested if self.config.needs_sphinx and \ self.config.needs_sphinx > sphinx.__version__[:3]: raise VersionRequirementError( 'This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.' % self.config.needs_sphinx) # set up translation infrastructure self._init_i18n() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(buildername) def _init_i18n(self): """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) locale_dirs = [None, path.join(package_dir, 'locale')] + \ [path.join(self.srcdir, x) for x in self.config.locale_dirs] else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation: self.info('done') else: self.info('locale not available') def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle(self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception, err: if type(err) is IOError and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn)
def setup_module(): global app, env app = TestApp(srcdir='(temp)') env = BuildEnvironment(app.srcdir, app.doctreedir, app.config) env.set_warnfunc(warnings.append)
class Sphinx: """The main application class and extensibility interface. :ivar srcdir: Directory containing source. :ivar confdir: Directory containing ``conf.py``. :ivar doctreedir: Directory for storing pickled doctrees. :ivar outdir: Directory for storing build documents. """ def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0, keep_going=False): # type: (str, str, str, str, str, Dict, IO, IO, bool, bool, List[str], int, int, bool) -> None # NOQA self.phase = BuildPhase.INITIALIZATION self.verbosity = verbosity self.extensions = {} # type: Dict[str, Extension] self.builder = None # type: Builder self.env = None # type: BuildEnvironment self.project = None # type: Project self.registry = SphinxComponentRegistry() self.html_themes = {} # type: Dict[str, str] # validate provided directories self.srcdir = abspath(srcdir) self.outdir = abspath(outdir) self.doctreedir = abspath(doctreedir) self.confdir = confdir if self.confdir: # confdir is optional self.confdir = abspath(self.confdir) if not path.isfile(path.join(self.confdir, 'conf.py')): raise ApplicationError(__("config directory doesn't contain a " "conf.py file (%s)") % confdir) if not path.isdir(self.srcdir): raise ApplicationError(__('Cannot find source directory (%s)') % self.srcdir) if self.srcdir == self.outdir: raise ApplicationError(__('Source directory and destination ' 'directory cannot be identical')) self.parallel = parallel if status is None: self._status = StringIO() # type: IO self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = StringIO() # type: IO else: self._warning = warning self._warncount = 0 self.keep_going = warningiserror and keep_going if self.keep_going: self.warningiserror = False else: self.warningiserror = warningiserror logging.setup(self, self._status, self._warning) self.events = EventManager(self) # keep last few messages for traceback # This will be filled by sphinx.util.logging.LastMessagesWriter self.messagelog = deque(maxlen=10) # type: deque # say hello to the world logger.info(bold(__('Running Sphinx v%s') % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 # read config self.tags = Tags(tags) if self.confdir is None: self.config = Config({}, confoverrides or {}) else: self.config = Config.read(self.confdir, confoverrides or {}, self.tags) # initialize some limited config variables before initialize i18n and loading # extensions self.config.pre_init_values() # set up translation infrastructure self._init_i18n() # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__: raise VersionRequirementError( __('This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.') % self.config.needs_sphinx) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all built-in extension modules for extension in builtin_extensions: self.setup_extension(extension) # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # preload builder module (before init config values) self.preload_builder(buildername) if not path.isdir(outdir): with progress_message(__('making output directory')): ensuredir(outdir) # the config file itself can be an extension if self.config.setup: prefix = __('while setting up extension %s:') % "conf.py" with prefixed_warnings(prefix): if callable(self.config.setup): self.config.setup(self) else: raise ConfigError( __("'setup' as currently defined in conf.py isn't a Python callable. " "Please modify its definition to make it a callable function. " "This is needed for conf.py to behave as a Sphinx extension.") ) # now that we know all config values, collect them from conf.py self.config.init_values() self.events.emit('config-inited', self.config) # create the project self.project = Project(self.srcdir, self.config.source_suffix) # create the builder self.builder = self.create_builder(buildername) # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder() def _init_i18n(self): # type: () -> None """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is None: self.translator, has_translation = locale.init([], None) else: logger.info(bold(__('loading translations [%s]... ') % self.config.language), nonl=True) # compile mo files if sphinx.po file in user locale directories are updated repo = CatalogRepository(self.srcdir, self.config.locale_dirs, self.config.language, self.config.source_encoding) for catalog in repo.catalogs: if catalog.domain == 'sphinx' and catalog.is_outdated(): catalog.write_mo(self.config.language) locale_dirs = [None, path.join(package_dir, 'locale')] + list(repo.locale_dirs) self.translator, has_translation = locale.init(locale_dirs, self.config.language) if has_translation or self.config.language == 'en': # "en" never needs to be translated logger.info(__('done')) else: logger.info(__('not available for built-in messages')) def _init_env(self, freshenv): # type: (bool) -> None filename = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if freshenv or not os.path.exists(filename): self.env = BuildEnvironment() self.env.setup(self) self.env.find_files(self.config, self.builder) else: try: with progress_message(__('loading pickled environment')): with open(filename, 'rb') as f: self.env = pickle.load(f) self.env.setup(self) except Exception as err: logger.info(__('failed: %s'), err) self._init_env(freshenv=True) def preload_builder(self, name): # type: (str) -> None self.registry.preload_builder(self, name) def create_builder(self, name): # type: (str) -> Builder if name is None: logger.info(__('No builder selected, using default: html')) name = 'html' return self.registry.create_builder(self, name) def _init_builder(self): # type: () -> None self.builder.set_environment(self.env) self.builder.init() self.events.emit('builder-inited') # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): # type: (bool, List[str]) -> None self.phase = BuildPhase.READING try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() if self._warncount and self.keep_going: self.statuscode = 1 status = (self.statuscode == 0 and __('succeeded') or __('finished with problems')) if self._warncount: if self.warningiserror: msg = __('build %s, %s warning (with warnings treated as errors).', 'build %s, %s warnings (with warnings treated as errors).', self._warncount) else: msg = __('build %s, %s warning.', 'build %s, %s warnings.', self._warncount) logger.info(bold(msg % (status, self._warncount))) else: logger.info(bold(__('build %s.') % status)) if self.statuscode == 0 and self.builder.epilog: logger.info('') logger.info(self.builder.epilog % { 'outdir': relpath(self.outdir), 'project': self.config.project }) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.events.emit('build-finished', err) raise else: self.events.emit('build-finished', None) self.builder.cleanup() # ---- general extensibility interface ------------------------------------- def setup_extension(self, extname): # type: (str) -> None """Import and setup a Sphinx extension module. Load the extension given by the module *name*. Use this if your extension needs the features provided by another extension. No-op if called twice. """ logger.debug('[app] setting up extension: %r', extname) self.registry.load_extension(self, extname) def require_sphinx(self, version): # type: (str) -> None """Check the Sphinx version if requested. Compare *version* (which must be a ``major.minor`` version string, e.g. ``'1.1'``) with the version of the running Sphinx, and abort the build when it is too old. .. versionadded:: 1.0 """ if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) # event interface def connect(self, event, callback): # type: (str, Callable) -> int """Register *callback* to be called when *event* is emitted. For details on available core events and the arguments of callback functions, please see :ref:`events`. The method returns a "listener ID" that can be used as an argument to :meth:`disconnect`. """ listener_id = self.events.connect(event, callback) logger.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): # type: (int) -> None """Unregister callback by *listener_id*.""" logger.debug('[app] disconnecting event: [id=%s]', listener_id) self.events.disconnect(listener_id) def emit(self, event, *args): # type: (str, Any) -> List """Emit *event* and pass *arguments* to the callback functions. Return the return values of all callbacks as a list. Do not emit core Sphinx events in extensions! """ return self.events.emit(event, *args) def emit_firstresult(self, event, *args): # type: (str, Any) -> Any """Emit *event* and pass *arguments* to the callback functions. Return the result of the first callback that doesn't return ``None``. .. versionadded:: 0.5 """ return self.events.emit_firstresult(event, *args) # registering addon parts def add_builder(self, builder, override=False): # type: (Type[Builder], bool) -> None """Register a new builder. *builder* must be a class that inherits from :class:`~sphinx.builders.Builder`. .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_builder(builder, override=override) # TODO(stephenfin): Describe 'types' parameter def add_config_value(self, name, default, rebuild, types=()): # type: (str, Any, Union[bool, str], Any) -> None """Register a configuration value. This is necessary for Sphinx to recognize new values and set default values accordingly. The *name* should be prefixed with the extension name, to avoid clashes. The *default* value can be any Python object. The string value *rebuild* must be one of those values: * ``'env'`` if a change in the setting only takes effect when a document is parsed -- this means that the whole environment must be rebuilt. * ``'html'`` if a change in the setting needs a full rebuild of HTML documents. * ``''`` if a change in the setting will not need any special rebuild. .. versionchanged:: 0.6 Changed *rebuild* from a simple boolean (equivalent to ``''`` or ``'env'``) to a string. However, booleans are still accepted and converted internally. .. versionchanged:: 0.4 If the *default* value is a callable, it will be called with the config object as its argument in order to get the default value. This can be used to implement config values whose default depends on other values. """ logger.debug('[app] adding config value: %r', (name, default, rebuild) + ((types,) if types else ())) # type: ignore if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.add(name, default, rebuild, types) def add_event(self, name): # type: (str) -> None """Register an event called *name*. This is needed to be able to emit it. """ logger.debug('[app] adding event: %r', name) self.events.add(name) def set_translator(self, name, translator_class, override=False): # type: (str, Type[nodes.NodeVisitor], bool) -> None """Register or override a Docutils translator class. This is used to register a custom output translator or to replace a builtin translator. This allows extensions to use custom translator and define custom nodes for the translator (see :meth:`add_node`). .. versionadded:: 1.3 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_translator(name, translator_class, override=override) def add_node(self, node, override=False, **kwds): # type: (Type[nodes.Element], bool, Any) -> None """Register a Docutils node class. This is necessary for Docutils internals. It may also be used in the future to validate nodes in the parsed documents. Node visitor functions for the Sphinx HTML, LaTeX, text and manpage writers can be given as keyword arguments: the keyword should be one or more of ``'html'``, ``'latex'``, ``'text'``, ``'man'``, ``'texinfo'`` or any other supported translators, the value a 2-tuple of ``(visit, depart)`` methods. ``depart`` can be ``None`` if the ``visit`` function raises :exc:`docutils.nodes.SkipNode`. Example: .. code-block:: python class math(docutils.nodes.Element): pass def visit_math_html(self, node): self.body.append(self.starttag(node, 'math')) def depart_math_html(self, node): self.body.append('</math>') app.add_node(math, html=(visit_math_html, depart_math_html)) Obviously, translators for which you don't specify visitor methods will choke on the node when encountered in a document to translate. .. versionchanged:: 0.5 Added the support for keyword arguments giving visit functions. """ logger.debug('[app] adding node: %r', (node, kwds)) if not override and docutils.is_node_registered(node): logger.warning(__('node class %r is already registered, ' 'its visitors will be overridden'), node.__name__, type='app', subtype='add_node') docutils.register_node(node) self.registry.add_translation_handlers(node, **kwds) def add_enumerable_node(self, node, figtype, title_getter=None, override=False, **kwds): # type: (Type[nodes.Element], str, TitleGetter, bool, Any) -> None """Register a Docutils node class as a numfig target. Sphinx numbers the node automatically. And then the users can refer it using :rst:role:`numref`. *figtype* is a type of enumerable nodes. Each figtypes have individual numbering sequences. As a system figtypes, ``figure``, ``table`` and ``code-block`` are defined. It is able to add custom nodes to these default figtypes. It is also able to define new custom figtype if new figtype is given. *title_getter* is a getter function to obtain the title of node. It takes an instance of the enumerable node, and it must return its title as string. The title is used to the default title of references for :rst:role:`ref`. By default, Sphinx searches ``docutils.nodes.caption`` or ``docutils.nodes.title`` from the node as a title. Other keyword arguments are used for node visitor functions. See the :meth:`.Sphinx.add_node` for details. .. versionadded:: 1.4 """ self.registry.add_enumerable_node(node, figtype, title_getter, override=override) self.add_node(node, override=override, **kwds) def add_directive(self, name, cls, override=False): # type: (str, Type[Directive], bool) -> None """Register a Docutils directive. *name* must be the prospective directive name. *cls* is a directive class which inherits ``docutils.parsers.rst.Directive``. For more details, see `the Docutils docs <http://docutils.sourceforge.net/docs/howto/rst-directives.html>`_ . For example, the (already existing) :rst:dir:`literalinclude` directive would be added like this: .. code-block:: python from docutils.parsers.rst import Directive, directives class LiteralIncludeDirective(Directive): has_content = True required_arguments = 1 optional_arguments = 0 final_argument_whitespace = True option_spec = { 'class': directives.class_option, 'name': directives.unchanged, } def run(self): ... add_directive('literalinclude', LiteralIncludeDirective) .. versionchanged:: 0.6 Docutils 0.5-style directive classes are now supported. .. deprecated:: 1.8 Docutils 0.4-style (function based) directives support is deprecated. .. versionchanged:: 1.8 Add *override* keyword. """ logger.debug('[app] adding directive: %r', (name, cls)) if not override and docutils.is_directive_registered(name): logger.warning(__('directive %r is already registered, it will be overridden'), name, type='app', subtype='add_directive') docutils.register_directive(name, cls) def add_role(self, name, role, override=False): # type: (str, Any, bool) -> None """Register a Docutils role. *name* must be the role name that occurs in the source, *role* the role function. Refer to the `Docutils documentation <http://docutils.sourceforge.net/docs/howto/rst-roles.html>`_ for more information. .. versionchanged:: 1.8 Add *override* keyword. """ logger.debug('[app] adding role: %r', (name, role)) if not override and docutils.is_role_registered(name): logger.warning(__('role %r is already registered, it will be overridden'), name, type='app', subtype='add_role') docutils.register_role(name, role) def add_generic_role(self, name, nodeclass, override=False): # type: (str, Any, bool) -> None """Register a generic Docutils role. Register a Docutils role that does nothing but wrap its contents in the node given by *nodeclass*. .. versionadded:: 0.6 .. versionchanged:: 1.8 Add *override* keyword. """ # Don't use ``roles.register_generic_role`` because it uses # ``register_canonical_role``. logger.debug('[app] adding generic role: %r', (name, nodeclass)) if not override and docutils.is_role_registered(name): logger.warning(__('role %r is already registered, it will be overridden'), name, type='app', subtype='add_generic_role') role = roles.GenericRole(name, nodeclass) docutils.register_role(name, role) def add_domain(self, domain, override=False): # type: (Type[Domain], bool) -> None """Register a domain. Make the given *domain* (which must be a class; more precisely, a subclass of :class:`~sphinx.domains.Domain`) known to Sphinx. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_domain(domain, override=override) def add_directive_to_domain(self, domain, name, cls, override=False): # type: (str, str, Type[Directive], bool) -> None """Register a Docutils directive in a domain. Like :meth:`add_directive`, but the directive is added to the domain named *domain*. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_directive_to_domain(domain, name, cls, override=override) def add_role_to_domain(self, domain, name, role, override=False): # type: (str, str, Union[RoleFunction, XRefRole], bool) -> None """Register a Docutils role in a domain. Like :meth:`add_role`, but the role is added to the domain named *domain*. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_role_to_domain(domain, name, role, override=override) def add_index_to_domain(self, domain, index, override=False): # type: (str, Type[Index], bool) -> None """Register a custom index for a domain. Add a custom *index* class to the domain named *domain*. *index* must be a subclass of :class:`~sphinx.domains.Index`. .. versionadded:: 1.0 .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_index_to_domain(domain, index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[], override=False): # type: (str, str, str, Callable, Type[nodes.TextElement], str, List, bool) -> None """Register a new object type. This method is a very convenient way to add a new :term:`object` type that can be cross-referenced. It will do this: - Create a new directive (called *directivename*) for documenting an object. It will automatically add index entries if *indextemplate* is nonempty; if given, it must contain exactly one instance of ``%s``. See the example below for how the template will be interpreted. - Create a new role (called *rolename*) to cross-reference to these object descriptions. - If you provide *parse_node*, it must be a function that takes a string and a docutils node, and it must populate the node with children parsed from the string. It must then return the name of the item to be used in cross-referencing and index entries. See the :file:`conf.py` file in the source for this documentation for an example. - The *objname* (if not given, will default to *directivename*) names the type of object. It is used when listing objects, e.g. in search results. For example, if you have this call in a custom Sphinx extension:: app.add_object_type('directive', 'dir', 'pair: %s; directive') you can use this markup in your documents:: .. rst:directive:: function Document a function. <...> See also the :rst:dir:`function` directive. For the directive, an index entry will be generated as if you had prepended :: .. index:: pair: function; directive The reference node will be of class ``literal`` (so it will be rendered in a proportional font, as appropriate for code) unless you give the *ref_nodeclass* argument, which must be a docutils node class. Most useful are ``docutils.nodes.emphasis`` or ``docutils.nodes.strong`` -- you can also use ``docutils.nodes.generated`` if you want no further text decoration. If the text should be treated as literal (e.g. no smart quote replacement), but not have typewriter styling, use ``sphinx.addnodes.literal_emphasis`` or ``sphinx.addnodes.literal_strong``. For the role content, you have the same syntactical possibilities as for standard Sphinx roles (see :ref:`xref-syntax`). .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_object_type(directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types, override=override) def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname='', override=False): # type: (str, str, str, Type[nodes.TextElement], str, bool) -> None """Register a new crossref object type. This method is very similar to :meth:`add_object_type` except that the directive it generates must be empty, and will produce no output. That means that you can add semantic targets to your sources, and refer to them using custom roles instead of generic ones (like :rst:role:`ref`). Example call:: app.add_crossref_type('topic', 'topic', 'single: %s', docutils.nodes.emphasis) Example usage:: .. topic:: application API The application API ------------------- Some random text here. See also :topic:`this section <application API>`. (Of course, the element following the ``topic`` directive needn't be a section.) .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_crossref_type(directivename, rolename, indextemplate, ref_nodeclass, objname, override=override) def add_transform(self, transform): # type: (Type[Transform]) -> None """Register a Docutils transform to be applied after parsing. Add the standard docutils :class:`Transform` subclass *transform* to the list of transforms that are applied after Sphinx parses a reST document. .. list-table:: priority range categories for Sphinx transforms :widths: 20,80 * - Priority - Main purpose in Sphinx * - 0-99 - Fix invalid nodes by docutils. Translate a doctree. * - 100-299 - Preparation * - 300-399 - early * - 400-699 - main * - 700-799 - Post processing. Deadline to modify text and referencing. * - 800-899 - Collect referencing and referenced nodes. Domain processing. * - 900-999 - Finalize and clean up. refs: `Transform Priority Range Categories`__ __ http://docutils.sourceforge.net/docs/ref/transforms.html#transform-priority-range-categories """ # NOQA self.registry.add_transform(transform) def add_post_transform(self, transform): # type: (Type[Transform]) -> None """Register a Docutils transform to be applied before writing. Add the standard docutils :class:`Transform` subclass *transform* to the list of transforms that are applied before Sphinx writes a document. """ self.registry.add_post_transform(transform) def add_javascript(self, filename, **kwargs): # type: (str, **str) -> None """An alias of :meth:`add_js_file`.""" warnings.warn('The app.add_javascript() is deprecated. ' 'Please use app.add_js_file() instead.', RemovedInSphinx40Warning, stacklevel=2) self.add_js_file(filename, **kwargs) def add_js_file(self, filename, **kwargs): # type: (str, **str) -> None """Register a JavaScript file to include in the HTML output. Add *filename* to the list of JavaScript files that the default HTML template will include. The filename must be relative to the HTML static path , or a full URI with scheme. The keyword arguments are also accepted for attributes of ``<script>`` tag. Example:: app.add_js_file('example.js') # => <script src="_static/example.js"></script> app.add_js_file('example.js', async="async") # => <script src="_static/example.js" async="async"></script> .. versionadded:: 0.5 .. versionchanged:: 1.8 Renamed from ``app.add_javascript()``. And it allows keyword arguments as attributes of script tag. """ self.registry.add_js_file(filename, **kwargs) if hasattr(self.builder, 'add_js_file'): self.builder.add_js_file(filename, **kwargs) # type: ignore def add_css_file(self, filename, **kwargs): # type: (str, **str) -> None """Register a stylesheet to include in the HTML output. Add *filename* to the list of CSS files that the default HTML template will include. The filename must be relative to the HTML static path, or a full URI with scheme. The keyword arguments are also accepted for attributes of ``<link>`` tag. Example:: app.add_css_file('custom.css') # => <link rel="stylesheet" href="_static/custom.css" type="text/css" /> app.add_css_file('print.css', media='print') # => <link rel="stylesheet" href="_static/print.css" # type="text/css" media="print" /> app.add_css_file('fancy.css', rel='alternate stylesheet', title='fancy') # => <link rel="alternate stylesheet" href="_static/fancy.css" # type="text/css" title="fancy" /> .. versionadded:: 1.0 .. versionchanged:: 1.6 Optional ``alternate`` and/or ``title`` attributes can be supplied with the *alternate* (of boolean type) and *title* (a string) arguments. The default is no title and *alternate* = ``False``. For more information, refer to the `documentation <https://mdn.io/Web/CSS/Alternative_style_sheets>`__. .. versionchanged:: 1.8 Renamed from ``app.add_stylesheet()``. And it allows keyword arguments as attributes of link tag. """ logger.debug('[app] adding stylesheet: %r', filename) self.registry.add_css_files(filename, **kwargs) if hasattr(self.builder, 'add_css_file'): self.builder.add_css_file(filename, **kwargs) # type: ignore def add_stylesheet(self, filename, alternate=False, title=None): # type: (str, bool, str) -> None """An alias of :meth:`add_css_file`.""" warnings.warn('The app.add_stylesheet() is deprecated. ' 'Please use app.add_css_file() instead.', RemovedInSphinx40Warning, stacklevel=2) attributes = {} # type: Dict[str, str] if alternate: attributes['rel'] = 'alternate stylesheet' else: attributes['rel'] = 'stylesheet' if title: attributes['title'] = title self.add_css_file(filename, **attributes) def add_latex_package(self, packagename, options=None): # type: (str, str) -> None r"""Register a package to include in the LaTeX source code. Add *packagename* to the list of packages that LaTeX source code will include. If you provide *options*, it will be taken to `\usepackage` declaration. .. code-block:: python app.add_latex_package('mypackage') # => \usepackage{mypackage} app.add_latex_package('mypackage', 'foo,bar') # => \usepackage[foo,bar]{mypackage} .. versionadded:: 1.3 """ self.registry.add_latex_package(packagename, options) def add_lexer(self, alias, lexer): # type: (str, Union[Lexer, Type[Lexer]]) -> None """Register a new lexer for source code. Use *lexer* to highlight code blocks with the given language *alias*. .. versionadded:: 0.6 .. versionchanged:: 2.1 Take a lexer class as an argument. An instance of lexers are still supported until Sphinx-3.x. """ logger.debug('[app] adding lexer: %r', (alias, lexer)) if isinstance(lexer, Lexer): warnings.warn('app.add_lexer() API changed; ' 'Please give lexer class instead instance', RemovedInSphinx40Warning) lexers[alias] = lexer else: lexer_classes[alias] = lexer def add_autodocumenter(self, cls, override=False): # type: (Any, bool) -> None """Register a new documenter class for the autodoc extension. Add *cls* as a new documenter class for the :mod:`sphinx.ext.autodoc` extension. It must be a subclass of :class:`sphinx.ext.autodoc.Documenter`. This allows to auto-document new types of objects. See the source of the autodoc module for examples on how to subclass :class:`Documenter`. .. todo:: Add real docs for Documenter and subclassing .. versionadded:: 0.6 .. versionchanged:: 2.2 Add *override* keyword. """ logger.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext.autodoc.directive import AutodocDirective self.registry.add_documenter(cls.objtype, cls) self.add_directive('auto' + cls.objtype, AutodocDirective, override=override) def add_autodoc_attrgetter(self, typ, getter): # type: (Type, Callable[[Any, str, Any], Any]) -> None """Register a new ``getattr``-like function for the autodoc extension. Add *getter*, which must be a function with an interface compatible to the :func:`getattr` builtin, as the autodoc attribute getter for objects that are instances of *typ*. All cases where autodoc needs to get an attribute of a type are then handled by this function instead of :func:`getattr`. .. versionadded:: 0.6 """ logger.debug('[app] adding autodoc attrgetter: %r', (typ, getter)) self.registry.add_autodoc_attrgetter(typ, getter) def add_search_language(self, cls): # type: (Any) -> None """Register a new language for the HTML search index. Add *cls*, which must be a subclass of :class:`sphinx.search.SearchLanguage`, as a support language for building the HTML full-text search index. The class must have a *lang* attribute that indicates the language it should be used for. See :confval:`html_search_language`. .. versionadded:: 1.1 """ logger.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls def add_source_suffix(self, suffix, filetype, override=False): # type: (str, str, bool) -> None """Register a suffix of source files. Same as :confval:`source_suffix`. The users can override this using the setting. .. versionadded:: 1.8 """ self.registry.add_source_suffix(suffix, filetype, override=override) def add_source_parser(self, *args, **kwargs): # type: (Any, Any) -> None """Register a parser class. .. versionadded:: 1.4 .. versionchanged:: 1.8 *suffix* argument is deprecated. It only accepts *parser* argument. Use :meth:`add_source_suffix` API to register suffix instead. .. versionchanged:: 1.8 Add *override* keyword. """ self.registry.add_source_parser(*args, **kwargs) def add_env_collector(self, collector): # type: (Type[EnvironmentCollector]) -> None """Register an environment collector class. Refer to :ref:`collector-api`. .. versionadded:: 1.6 """ logger.debug('[app] adding environment collector: %r', collector) collector().enable(self) def add_html_theme(self, name, theme_path): # type: (str, str) -> None """Register a HTML Theme. The *name* is a name of theme, and *path* is a full path to the theme (refs: :ref:`distribute-your-theme`). .. versionadded:: 1.6 """ logger.debug('[app] adding HTML theme: %r, %r', name, theme_path) self.html_themes[name] = theme_path def add_html_math_renderer(self, name, inline_renderers=None, block_renderers=None): # type: (str, Tuple[Callable, Callable], Tuple[Callable, Callable]) -> None """Register a math renderer for HTML. The *name* is a name of math renderer. Both *inline_renderers* and *block_renderers* are used as visitor functions for the HTML writer: the former for inline math node (``nodes.math``), the latter for block math node (``nodes.math_block``). Regarding visitor functions, see :meth:`add_node` for details. .. versionadded:: 1.8 """ self.registry.add_html_math_renderer(name, inline_renderers, block_renderers) def add_message_catalog(self, catalog, locale_dir): # type: (str, str) -> None """Register a message catalog. The *catalog* is a name of catalog, and *locale_dir* is a base path of message catalog. For more details, see :func:`sphinx.locale.get_translation()`. .. versionadded:: 1.8 """ locale.init([locale_dir], self.config.language, catalog) locale.init_console(locale_dir, catalog) # ---- other methods ------------------------------------------------- def is_parallel_allowed(self, typ): # type: (str) -> bool """Check parallel processing is allowed or not. ``typ`` is a type of processing; ``'read'`` or ``'write'``. """ if typ == 'read': attrname = 'parallel_read_safe' message_not_declared = __("the %s extension does not declare if it " "is safe for parallel reading, assuming " "it isn't - please ask the extension author " "to check and make it explicit") message_not_safe = __("the %s extension is not safe for parallel reading") elif typ == 'write': attrname = 'parallel_write_safe' message_not_declared = __("the %s extension does not declare if it " "is safe for parallel writing, assuming " "it isn't - please ask the extension author " "to check and make it explicit") message_not_safe = __("the %s extension is not safe for parallel writing") else: raise ValueError('parallel type %s is not supported' % typ) for ext in self.extensions.values(): allowed = getattr(ext, attrname, None) if allowed is None: logger.warning(message_not_declared, ext.name) logger.warning(__('doing serial %s'), typ) return False elif not allowed: logger.warning(message_not_safe, ext.name) logger.warning(__('doing serial %s'), typ) return False return True
def clear_doc(self, app: Sphinx, env: BuildEnvironment, docname: str) -> None: env.rjs_css_classes = set()
class Sphinx(object): def __init__( self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0, ): self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} self._extension_metadata = {} self._listeners = {} self.domains = BUILTIN_DOMAINS.copy() self.builderclasses = BUILTIN_BUILDERS.copy() self.builder = None self.env = None self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = cStringIO() self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = cStringIO() else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() self._translators = {} # keep last few messages for traceback self.messagelog = deque(maxlen=10) # say hello to the world self.info(bold("Running Sphinx v%s" % sphinx.__display_version__)) # status code for command-line application self.statuscode = 0 if not path.isdir(outdir): self.info("making output directory...") os.makedirs(outdir) # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # defer checking types until i18n has been initialized # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # extension loading support for alabaster theme # self.config.html_theme is not set from conf.py at here # for now, sphinx always load a 'alabaster' extension. if "alabaster" not in self.config.extensions: self.config.extensions.append("alabaster") # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: # py31 doesn't have 'callable' function for below check if hasattr(self.config.setup, "__call__"): self.config.setup(self) else: raise ConfigError( "'setup' that is specified in the conf.py has not been " + "callable. Please provide a callable `setup` function " + "in order to behave as a sphinx extension conf.py itself." ) # now that we know all config values, collect them from conf.py self.config.init_values(self.warn) # check the Sphinx version if requested if self.config.needs_sphinx and self.config.needs_sphinx > sphinx.__display_version__[:3]: raise VersionRequirementError( "This project needs at least Sphinx v%s and therefore cannot " "be built with this version." % self.config.needs_sphinx ) # check extension versions if requested if self.config.needs_extensions: for extname, needs_ver in self.config.needs_extensions.items(): if extname not in self._extensions: self.warn( "needs_extensions config value specifies a " "version requirement for extension %s, but it is " "not loaded" % extname ) continue has_ver = self._extension_metadata[extname]["version"] if has_ver == "unknown version" or needs_ver > has_ver: raise VersionRequirementError( "This project needs the extension %s at least in " "version %s and therefore cannot be built with the " "loaded version (%s)." % (extname, needs_ver, has_ver) ) # set up translation infrastructure self._init_i18n() # check all configuration values for permissible types self.config.check_types(self.warn) # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(buildername) def _init_i18n(self): """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold("loading translations [%s]... " % self.config.language), nonl=True) locale_dirs = [None, path.join(package_dir, "locale")] + [ path.join(self.srcdir, x) for x in self.config.locale_dirs ] else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == "en": # "en" never needs to be translated self.info("done") else: self.info("not available for built-in messages") def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold("loading pickled environment... "), nonl=True) self.env = BuildEnvironment.frompickle(self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info("done") except Exception as err: if isinstance(err, IOError) and err.errno == ENOENT: self.info("not yet created") else: self.info("failed: %s" % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn) def _init_builder(self, buildername): if buildername is None: print("No builder selected, using default: html", file=self._status) buildername = "html" if buildername not in self.builderclasses: raise SphinxError("Builder name %s not registered" % buildername) builderclass = self.builderclasses[buildername] if isinstance(builderclass, tuple): # builtin builder mod, cls = builderclass builderclass = getattr(__import__("sphinx.builders." + mod, None, None, [cls]), cls) self.builder = builderclass(self) self.emit("builder-inited") # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): try: if force_all: self.builder.compile_all_catalogs() self.builder.build_all() elif filenames: self.builder.compile_specific_catalogs(filenames) self.builder.build_specific(filenames) else: self.builder.compile_update_catalogs() self.builder.build_update() status = self.statuscode == 0 and "succeeded" or "finished with problems" if self._warncount: self.info( bold("build %s, %s warning%s." % (status, self._warncount, self._warncount != 1 and "s" or "")) ) else: self.info(bold("build %s." % status)) except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit("build-finished", err) raise else: self.emit("build-finished", None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def _log(self, message, wfile, nonl=False): try: wfile.write(message) except UnicodeEncodeError: encoding = getattr(wfile, "encoding", "ascii") or "ascii" wfile.write(message.encode(encoding, "replace")) if not nonl: wfile.write("\n") if hasattr(wfile, "flush"): wfile.flush() self.messagelog.append(message) def warn(self, message, location=None, prefix="WARNING: "): """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if isinstance(location, tuple): docname, lineno = location if docname: location = "%s:%s" % (self.env.doc2path(docname), lineno or "") else: location = None warntext = location and "%s: %s%s\n" % (location, prefix, message) or "%s%s\n" % (prefix, message) if self.warningiserror: raise SphinxWarning(warntext) self._warncount += 1 self._log(warntext, self._warning, True) def info(self, message="", nonl=False): """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ self._log(message, self._status, nonl) def verbose(self, message, *args, **kwargs): """Emit a verbose informational message. The message will only be emitted for verbosity levels >= 1 (i.e. at least one ``-v`` option was given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 1: return if args or kwargs: message = message % (args or kwargs) self._log(message, self._status) def debug(self, message, *args, **kwargs): """Emit a debug-level informational message. The message will only be emitted for verbosity levels >= 2 (i.e. at least two ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 2: return if args or kwargs: message = message % (args or kwargs) self._log(darkgray(message), self._status) def debug2(self, message, *args, **kwargs): """Emit a lowlevel debug-level informational message. The message will only be emitted for verbosity level 3 (i.e. three ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 3: return if args or kwargs: message = message % (args or kwargs) self._log(lightgray(message), self._status) def _display_chunk(chunk): if isinstance(chunk, (list, tuple)): if len(chunk) == 1: return text_type(chunk[0]) return "%s .. %s" % (chunk[0], chunk[-1]) return text_type(chunk) def old_status_iterator(self, iterable, summary, colorfunc=darkgreen, stringify_func=_display_chunk): l = 0 for item in iterable: if l == 0: self.info(bold(summary), nonl=1) l = 1 self.info(colorfunc(stringify_func(item)) + " ", nonl=1) yield item if l == 1: self.info() # new version with progress info def status_iterator(self, iterable, summary, colorfunc=darkgreen, length=0, stringify_func=_display_chunk): if length == 0: for item in self.old_status_iterator(iterable, summary, colorfunc, stringify_func): yield item return l = 0 summary = bold(summary) for item in iterable: l += 1 s = "%s[%3d%%] %s" % (summary, 100 * l / length, colorfunc(stringify_func(item))) if self.verbosity: s += "\n" else: s = term_width_line(s) self.info(s, nonl=1) yield item if l > 0: self.info() # ---- general extensibility interface ------------------------------------- def setup_extension(self, extension): """Import and setup a Sphinx extension module. No-op if called twice.""" self.debug("[app] setting up extension: %r", extension) if extension in self._extensions: return try: mod = __import__(extension, None, None, ["setup"]) except ImportError as err: self.verbose("Original exception:\n" + traceback.format_exc()) raise ExtensionError("Could not import extension %s" % extension, err) if not hasattr(mod, "setup"): self.warn("extension %r has no setup() function; is it really " "a Sphinx extension module?" % extension) ext_meta = None else: try: ext_meta = mod.setup(self) except VersionRequirementError as err: # add the extension name to the version required raise VersionRequirementError( "The %s extension used by this project needs at least " "Sphinx v%s; it therefore cannot be built with this " "version." % (extension, err) ) if ext_meta is None: ext_meta = {} if not ext_meta.get("version"): ext_meta["version"] = "unknown version" self._extensions[extension] = mod self._extension_metadata[extension] = ext_meta def require_sphinx(self, version): # check the Sphinx version if requested if version > sphinx.__display_version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): """Import an object from a 'module.name' string.""" return import_object(objname, source=None) # event interface def _validate_event(self, event): event = intern(event) if event not in self._events: raise ExtensionError("Unknown event name: %s" % event) def connect(self, event, callback): self._validate_event(event) listener_id = self.next_listener_id if event not in self._listeners: self._listeners[event] = {listener_id: callback} else: self._listeners[event][listener_id] = callback self.next_listener_id += 1 self.debug("[app] connecting event %r: %r [id=%s]", event, callback, listener_id) return listener_id def disconnect(self, listener_id): self.debug("[app] disconnecting event: [id=%s]", listener_id) for event in itervalues(self._listeners): event.pop(listener_id, None) def emit(self, event, *args): try: self.debug2("[app] emitting event: %r%s", event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass results = [] if event in self._listeners: for _, callback in iteritems(self._listeners[event]): results.append(callback(self, *args)) return results def emit_firstresult(self, event, *args): for result in self.emit(event, *args): if result is not None: return result return None # registering addon parts def add_builder(self, builder): self.debug("[app] adding builder: %r", builder) if not hasattr(builder, "name"): raise ExtensionError('Builder class %s has no "name" attribute' % builder) if builder.name in self.builderclasses: if isinstance(self.builderclasses[builder.name], tuple): raise ExtensionError("Builder %r is a builtin builder" % builder.name) else: raise ExtensionError( "Builder %r already exists (in module %s)" % (builder.name, self.builderclasses[builder.name].__module__) ) self.builderclasses[builder.name] = builder def add_config_value(self, name, default, rebuild): self.debug("[app] adding config value: %r", (name, default, rebuild)) if name in self.config.values: raise ExtensionError("Config value %r already present" % name) if rebuild in (False, True): rebuild = rebuild and "env" or "" self.config.values[name] = (default, rebuild) def add_event(self, name): self.debug("[app] adding event: %r", name) if name in self._events: raise ExtensionError("Event %r already present" % name) self._events[name] = "" def set_translator(self, name, translator_class): self.info(bold("A Translator for the %s builder is changed." % name)) self._translators[name] = translator_class def add_node(self, node, **kwds): self.debug("[app] adding node: %r", (node, kwds)) nodes._add_node_class_names([node.__name__]) for key, val in iteritems(kwds): try: visit, depart = val except ValueError: raise ExtensionError("Value for key %r must be a " "(visit, depart) function tuple" % key) translator = self._translators.get(key) if translator is not None: pass elif key == "html": from sphinx.writers.html import HTMLTranslator as translator elif key == "latex": from sphinx.writers.latex import LaTeXTranslator as translator elif key == "text": from sphinx.writers.text import TextTranslator as translator elif key == "man": from sphinx.writers.manpage import ManualPageTranslator as translator elif key == "texinfo": from sphinx.writers.texinfo import TexinfoTranslator as translator else: # ignore invalid keys for compatibility continue setattr(translator, "visit_" + node.__name__, visit) if depart: setattr(translator, "depart_" + node.__name__, depart) def _directive_helper(self, obj, content=None, arguments=None, **options): if isinstance(obj, (types.FunctionType, types.MethodType)): obj.content = content obj.arguments = arguments or (0, 0, False) obj.options = options return convert_directive_function(obj) else: if content or arguments or options: raise ExtensionError("when adding directive classes, no " "additional arguments may be given") return obj def add_directive(self, name, obj, content=None, arguments=None, **options): self.debug("[app] adding directive: %r", (name, obj, content, arguments, options)) directives.register_directive(name, self._directive_helper(obj, content, arguments, **options)) def add_role(self, name, role): self.debug("[app] adding role: %r", (name, role)) roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # don't use roles.register_generic_role because it uses # register_canonical_role self.debug("[app] adding generic role: %r", (name, nodeclass)) role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): self.debug("[app] adding domain: %r", domain) if domain.name in self.domains: raise ExtensionError("domain %s already registered" % domain.name) self.domains[domain.name] = domain def override_domain(self, domain): self.debug("[app] overriding domain: %r", domain) if domain.name not in self.domains: raise ExtensionError("domain %s not yet registered" % domain.name) if not issubclass(domain, self.domains[domain.name]): raise ExtensionError("new domain not a subclass of registered %s " "domain" % domain.name) self.domains[domain.name] = domain def add_directive_to_domain(self, domain, name, obj, content=None, arguments=None, **options): self.debug("[app] adding directive to domain: %r", (domain, name, obj, content, arguments, options)) if domain not in self.domains: raise ExtensionError("domain %s not yet registered" % domain) self.domains[domain].directives[name] = self._directive_helper(obj, content, arguments, **options) def add_role_to_domain(self, domain, name, role): self.debug("[app] adding role to domain: %r", (domain, name, role)) if domain not in self.domains: raise ExtensionError("domain %s not yet registered" % domain) self.domains[domain].roles[name] = role def add_index_to_domain(self, domain, index): self.debug("[app] adding index to domain: %r", (domain, index)) if domain not in self.domains: raise ExtensionError("domain %s not yet registered" % domain) self.domains[domain].indices.append(index) def add_object_type( self, directivename, rolename, indextemplate="", parse_node=None, ref_nodeclass=None, objname="", doc_field_types=[], ): self.debug( "[app] adding object type: %r", (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types), ) StandardDomain.object_types[directivename] = ObjType(objname or directivename, rolename) # create a subclass of GenericObject as the new directive new_directive = type( directivename, (GenericObject, object), { "indextemplate": indextemplate, "parse_node": staticmethod(parse_node), "doc_field_types": doc_field_types, }, ) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) # backwards compatible alias add_description_unit = add_object_type def add_crossref_type(self, directivename, rolename, indextemplate="", ref_nodeclass=None, objname=""): self.debug("[app] adding crossref type: %r", (directivename, rolename, indextemplate, ref_nodeclass, objname)) StandardDomain.object_types[directivename] = ObjType(objname or directivename, rolename) # create a subclass of Target as the new directive new_directive = type(directivename, (Target, object), {"indextemplate": indextemplate}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) def add_transform(self, transform): self.debug("[app] adding transform: %r", transform) SphinxStandaloneReader.transforms.append(transform) def add_javascript(self, filename): self.debug("[app] adding javascript: %r", filename) from sphinx.builders.html import StandaloneHTMLBuilder if "://" in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append(posixpath.join("_static", filename)) def add_stylesheet(self, filename): self.debug("[app] adding stylesheet: %r", filename) from sphinx.builders.html import StandaloneHTMLBuilder if "://" in filename: StandaloneHTMLBuilder.css_files.append(filename) else: StandaloneHTMLBuilder.css_files.append(posixpath.join("_static", filename)) def add_latex_package(self, packagename, options=None): self.debug("[app] adding latex package: %r", packagename) from sphinx.builders.latex import LaTeXBuilder LaTeXBuilder.usepackages.append((packagename, options)) def add_lexer(self, alias, lexer): self.debug("[app] adding lexer: %r", (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): self.debug("[app] adding autodocumenter: %r", cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive("auto" + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): self.debug("[app] adding autodoc attrgetter: %r", (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): self.debug("[app] adding search language: %r", cls) from sphinx.search import languages, SearchLanguage assert issubclass(cls, SearchLanguage) languages[cls.lang] = cls
def merge_other(self, app: Sphinx, env: BuildEnvironment, docnames: Set[str], other: BuildEnvironment) -> None: env.rjs_css_classes = getattr(env, 'rjs_css_classes', []) | getattr( other, 'rjs_css_classes', [])
class Sphinx(object): def __init__(self, srcdir, confdir, outdir, doctreedir, buildername, confoverrides=None, status=sys.stdout, warning=sys.stderr, freshenv=False, warningiserror=False, tags=None, verbosity=0, parallel=0): self.verbosity = verbosity self.next_listener_id = 0 self._extensions = {} self._listeners = {} self.domains = BUILTIN_DOMAINS.copy() self.builderclasses = BUILTIN_BUILDERS.copy() self.builder = None self.env = None self.srcdir = srcdir self.confdir = confdir self.outdir = outdir self.doctreedir = doctreedir self.parallel = parallel if status is None: self._status = StringIO() self.quiet = True else: self._status = status self.quiet = False if warning is None: self._warning = StringIO() else: self._warning = warning self._warncount = 0 self.warningiserror = warningiserror self._events = events.copy() # say hello to the world self.info(bold('Running Sphinx v%s' % sphinx.__version__)) # status code for command-line application self.statuscode = 0 # read config self.tags = Tags(tags) self.config = Config(confdir, CONFIG_FILENAME, confoverrides or {}, self.tags) self.config.check_unicode(self.warn) # set confdir to srcdir if -C given (!= no confdir); a few pieces # of code expect a confdir to be set if self.confdir is None: self.confdir = self.srcdir # load all user-given extension modules for extension in self.config.extensions: self.setup_extension(extension) # the config file itself can be an extension if self.config.setup: self.config.setup(self) # now that we know all config values, collect them from conf.py self.config.init_values(self.warn) # check the Sphinx version if requested if self.config.needs_sphinx and \ self.config.needs_sphinx > sphinx.__version__[:3]: raise VersionRequirementError( 'This project needs at least Sphinx v%s and therefore cannot ' 'be built with this version.' % self.config.needs_sphinx) # set up translation infrastructure self._init_i18n() # set up the build environment self._init_env(freshenv) # set up the builder self._init_builder(buildername) def _init_i18n(self): """Load translated strings from the configured localedirs if enabled in the configuration. """ if self.config.language is not None: self.info(bold('loading translations [%s]... ' % self.config.language), nonl=True) locale_dirs = [None, path.join(package_dir, 'locale')] + \ [path.join(self.srcdir, x) for x in self.config.locale_dirs] else: locale_dirs = [] self.translator, has_translation = locale.init(locale_dirs, self.config.language) if self.config.language is not None: if has_translation or self.config.language == 'en': # "en" never needs to be translated self.info('done') else: self.info('not available for built-in messages') def _init_env(self, freshenv): if freshenv: self.env = BuildEnvironment(self.srcdir, self.doctreedir, self.config) self.env.find_files(self.config) for domain in self.domains.keys(): self.env.domains[domain] = self.domains[domain](self.env) else: try: self.info(bold('loading pickled environment... '), nonl=True) self.env = BuildEnvironment.frompickle(self.config, path.join(self.doctreedir, ENV_PICKLE_FILENAME)) self.env.domains = {} for domain in self.domains.keys(): # this can raise if the data version doesn't fit self.env.domains[domain] = self.domains[domain](self.env) self.info('done') except Exception as err: if type(err) is IOError and err.errno == ENOENT: self.info('not yet created') else: self.info('failed: %s' % err) return self._init_env(freshenv=True) self.env.set_warnfunc(self.warn) def _init_builder(self, buildername): if buildername is None: print('No builder selected, using default: html', file=self._status) buildername = 'html' if buildername not in self.builderclasses: raise SphinxError('Builder name %s not registered' % buildername) builderclass = self.builderclasses[buildername] if isinstance(builderclass, tuple): # builtin builder mod, cls = builderclass builderclass = getattr( __import__('sphinx.builders.' + mod, None, None, [cls]), cls) self.builder = builderclass(self) self.emit('builder-inited') # ---- main "build" method ------------------------------------------------- def build(self, force_all=False, filenames=None): try: if force_all: self.builder.build_all() elif filenames: self.builder.build_specific(filenames) else: self.builder.build_update() except Exception as err: # delete the saved env to force a fresh build next time envfile = path.join(self.doctreedir, ENV_PICKLE_FILENAME) if path.isfile(envfile): os.unlink(envfile) self.emit('build-finished', err) raise else: self.emit('build-finished', None) self.builder.cleanup() # ---- logging handling ---------------------------------------------------- def _log(self, message, wfile, nonl=False): try: wfile.write(message) except UnicodeEncodeError: encoding = getattr(wfile, 'encoding', 'ascii') or 'ascii' wfile.write(message.encode(encoding, 'replace')) if not nonl: wfile.write('\n') if hasattr(wfile, 'flush'): wfile.flush() def warn(self, message, location=None, prefix='WARNING: '): """Emit a warning. If *location* is given, it should either be a tuple of (docname, lineno) or a string describing the location of the warning as well as possible. *prefix* usually should not be changed. .. note:: For warnings emitted during parsing, you should use :meth:`.BuildEnvironment.warn` since that will collect all warnings during parsing for later output. """ if isinstance(location, tuple): docname, lineno = location if docname: location = '%s:%s' % (self.env.doc2path(docname), lineno or '') else: location = None warntext = location and '%s: %s%s\n' % (location, prefix, message) or \ '%s%s\n' % (prefix, message) if self.warningiserror: raise SphinxWarning(warntext) self._warncount += 1 self._log(warntext, self._warning, True) def info(self, message='', nonl=False): """Emit an informational message. If *nonl* is true, don't emit a newline at the end (which implies that more info output will follow soon.) """ self._log(message, self._status, nonl) def verbose(self, message, *args, **kwargs): """Emit a verbose informational message. The message will only be emitted for verbosity levels >= 1 (i.e. at least one ``-v`` option was given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 1: return if args or kwargs: message = message % (args or kwargs) self._log(message, self._status) def debug(self, message, *args, **kwargs): """Emit a debug-level informational message. The message will only be emitted for verbosity levels >= 2 (i.e. at least two ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 2: return if args or kwargs: message = message % (args or kwargs) self._log(darkgray(message), self._status) def debug2(self, message, *args, **kwargs): """Emit a lowlevel debug-level informational message. The message will only be emitted for verbosity level 3 (i.e. three ``-v`` options were given). The message can contain %-style interpolation placeholders, which is formatted with either the ``*args`` or ``**kwargs`` when output. """ if self.verbosity < 3: return if args or kwargs: message = message % (args or kwargs) self._log(lightgray(message), self._status) # ---- general extensibility interface ------------------------------------- def setup_extension(self, extension): """Import and setup a Sphinx extension module. No-op if called twice.""" self.debug('[app] setting up extension: %r', extension) if extension in self._extensions: return try: mod = __import__(extension, None, None, ['setup']) except ImportError as err: self.verbose('Original exception:\n' + traceback.format_exc()) raise ExtensionError('Could not import extension %s' % extension, err) if not hasattr(mod, 'setup'): self.warn('extension %r has no setup() function; is it really ' 'a Sphinx extension module?' % extension) else: try: mod.setup(self) except VersionRequirementError as err: # add the extension name to the version required raise VersionRequirementError( 'The %s extension used by this project needs at least ' 'Sphinx v%s; it therefore cannot be built with this ' 'version.' % (extension, err)) self._extensions[extension] = mod def require_sphinx(self, version): # check the Sphinx version if requested if version > sphinx.__version__[:3]: raise VersionRequirementError(version) def import_object(self, objname, source=None): """Import an object from a 'module.name' string.""" try: module, name = objname.rsplit('.', 1) except ValueError as err: raise ExtensionError('Invalid full object name %s' % objname + (source and ' (needed for %s)' % source or ''), err) try: return getattr(__import__(module, None, None, [name]), name) except ImportError as err: raise ExtensionError('Could not import %s' % module + (source and ' (needed for %s)' % source or ''), err) except AttributeError as err: raise ExtensionError('Could not find %s' % objname + (source and ' (needed for %s)' % source or ''), err) # event interface def _validate_event(self, event): event = intern(event) if event not in self._events: raise ExtensionError('Unknown event name: %s' % event) def connect(self, event, callback): self._validate_event(event) listener_id = self.next_listener_id if event not in self._listeners: self._listeners[event] = {listener_id: callback} else: self._listeners[event][listener_id] = callback self.next_listener_id += 1 self.debug('[app] connecting event %r: %r [id=%s]', event, callback, listener_id) return listener_id def disconnect(self, listener_id): self.debug('[app] disconnecting event: [id=%s]', listener_id) for event in self._listeners.itervalues(): event.pop(listener_id, None) def emit(self, event, *args): try: self.debug2('[app] emitting event: %r%s', event, repr(args)[:100]) except Exception: # not every object likes to be repr()'d (think # random stuff coming via autodoc) pass results = [] if event in self._listeners: for _, callback in self._listeners[event].iteritems(): results.append(callback(self, *args)) return results def emit_firstresult(self, event, *args): for result in self.emit(event, *args): if result is not None: return result return None # registering addon parts def add_builder(self, builder): self.debug('[app] adding builder: %r', builder) if not hasattr(builder, 'name'): raise ExtensionError('Builder class %s has no "name" attribute' % builder) if builder.name in self.builderclasses: if isinstance(self.builderclasses[builder.name], tuple): raise ExtensionError('Builder %r is a builtin builder' % builder.name) else: raise ExtensionError( 'Builder %r already exists (in module %s)' % ( builder.name, self.builderclasses[builder.name].__module__)) self.builderclasses[builder.name] = builder def add_config_value(self, name, default, rebuild): self.debug('[app] adding config value: %r', (name, default, rebuild)) if name in self.config.values: raise ExtensionError('Config value %r already present' % name) if rebuild in (False, True): rebuild = rebuild and 'env' or '' self.config.values[name] = (default, rebuild) def add_event(self, name): self.debug('[app] adding event: %r', name) if name in self._events: raise ExtensionError('Event %r already present' % name) self._events[name] = '' def add_node(self, node, **kwds): self.debug('[app] adding node: %r', (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 translator elif key == 'latex': from sphinx.writers.latex import LaTeXTranslator as translator elif key == 'text': from sphinx.writers.text import TextTranslator as translator elif key == 'man': from sphinx.writers.manpage import ManualPageTranslator \ as translator elif key == 'texinfo': from sphinx.writers.texinfo import TexinfoTranslator \ as translator else: # ignore invalid keys for compatibility continue setattr(translator, 'visit_'+node.__name__, visit) if depart: setattr(translator, 'depart_'+node.__name__, depart) def _directive_helper(self, obj, content=None, arguments=None, **options): if isinstance(obj, (types.FunctionType, types.MethodType)): obj.content = content obj.arguments = arguments or (0, 0, False) obj.options = options return convert_directive_function(obj) else: if content or arguments or options: raise ExtensionError('when adding directive classes, no ' 'additional arguments may be given') return obj def add_directive(self, name, obj, content=None, arguments=None, **options): self.debug('[app] adding directive: %r', (name, obj, content, arguments, options)) directives.register_directive( name, self._directive_helper(obj, content, arguments, **options)) def add_role(self, name, role): self.debug('[app] adding role: %r', (name, role)) roles.register_local_role(name, role) def add_generic_role(self, name, nodeclass): # don't use roles.register_generic_role because it uses # register_canonical_role self.debug('[app] adding generic role: %r', (name, nodeclass)) role = roles.GenericRole(name, nodeclass) roles.register_local_role(name, role) def add_domain(self, domain): self.debug('[app] adding domain: %r', domain) if domain.name in self.domains: raise ExtensionError('domain %s already registered' % domain.name) self.domains[domain.name] = domain def override_domain(self, domain): self.debug('[app] overriding domain: %r', domain) if domain.name not in self.domains: raise ExtensionError('domain %s not yet registered' % domain.name) if not issubclass(domain, self.domains[domain.name]): raise ExtensionError('new domain not a subclass of registered %s ' 'domain' % domain.name) self.domains[domain.name] = domain def add_directive_to_domain(self, domain, name, obj, content=None, arguments=None, **options): self.debug('[app] adding directive to domain: %r', (domain, name, obj, content, arguments, options)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].directives[name] = \ self._directive_helper(obj, content, arguments, **options) def add_role_to_domain(self, domain, name, role): self.debug('[app] adding role to domain: %r', (domain, name, role)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].roles[name] = role def add_index_to_domain(self, domain, index): self.debug('[app] adding index to domain: %r', (domain, index)) if domain not in self.domains: raise ExtensionError('domain %s not yet registered' % domain) self.domains[domain].indices.append(index) def add_object_type(self, directivename, rolename, indextemplate='', parse_node=None, ref_nodeclass=None, objname='', doc_field_types=[]): self.debug('[app] adding object type: %r', (directivename, rolename, indextemplate, parse_node, ref_nodeclass, objname, doc_field_types)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of GenericObject as the new directive new_directive = type(directivename, (GenericObject, object), {'indextemplate': indextemplate, 'parse_node': staticmethod(parse_node), 'doc_field_types': doc_field_types}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) # backwards compatible alias add_description_unit = add_object_type def add_crossref_type(self, directivename, rolename, indextemplate='', ref_nodeclass=None, objname=''): self.debug('[app] adding crossref type: %r', (directivename, rolename, indextemplate, ref_nodeclass, objname)) StandardDomain.object_types[directivename] = \ ObjType(objname or directivename, rolename) # create a subclass of Target as the new directive new_directive = type(directivename, (Target, object), {'indextemplate': indextemplate}) StandardDomain.directives[directivename] = new_directive # XXX support more options? StandardDomain.roles[rolename] = XRefRole(innernodeclass=ref_nodeclass) def add_transform(self, transform): self.debug('[app] adding transform: %r', transform) SphinxStandaloneReader.transforms.append(transform) def add_javascript(self, filename): self.debug('[app] adding javascript: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.script_files.append(filename) else: StandaloneHTMLBuilder.script_files.append( posixpath.join('_static', filename)) def add_stylesheet(self, filename): self.debug('[app] adding stylesheet: %r', filename) from sphinx.builders.html import StandaloneHTMLBuilder if '://' in filename: StandaloneHTMLBuilder.css_files.append(filename) else: StandaloneHTMLBuilder.css_files.append( posixpath.join('_static', filename)) def add_lexer(self, alias, lexer): self.debug('[app] adding lexer: %r', (alias, lexer)) from sphinx.highlighting import lexers if lexers is None: return lexers[alias] = lexer def add_autodocumenter(self, cls): self.debug('[app] adding autodocumenter: %r', cls) from sphinx.ext import autodoc autodoc.add_documenter(cls) self.add_directive('auto' + cls.objtype, autodoc.AutoDirective) def add_autodoc_attrgetter(self, type, getter): self.debug('[app] adding autodoc attrgetter: %r', (type, getter)) from sphinx.ext import autodoc autodoc.AutoDirective._special_attrgetters[type] = getter def add_search_language(self, cls): self.debug('[app] adding search language: %r', cls) from sphinx.search import languages, SearchLanguage assert isinstance(cls, SearchLanguage) languages[cls.lang] = cls
def missing_reference( app: Sphinx, env: BuildEnvironment, node: Element, contnode: TextElement ) -> Optional[nodes.reference]: """Linking to Qt documentation.""" target: str = node["reftarget"] inventories = InventoryAdapter(env) objtypes: Optional[List[str]] = None if node["reftype"] == "any": # we search anything! objtypes = [ "%s:%s" % (domain.name, objtype) for domain in env.domains.values() for objtype in domain.object_types ] domain = None else: domain = node.get("refdomain") if not domain: # only objects in domains are in the inventory return None objtypes = env.get_domain(domain).objtypes_for_role(node["reftype"]) if not objtypes: return None objtypes = ["%s:%s" % (domain, objtype) for objtype in objtypes] if target.startswith("PySide2"): head, tail = target.split(".", 1) target = "PyQt5." + tail if signal_pattern.match(target): uri = signal_slot_uri[app.config.qt_documentation] dispname = signal_name[app.config.qt_documentation] version = QT_VERSION elif slot_pattern.match(target): uri = signal_slot_uri[app.config.qt_documentation] dispname = slot_name[app.config.qt_documentation] version = QT_VERSION else: target_list = [target, "PyQt5." + target] target_list += [ name + "." + target for name in inventories.named_inventory["PyQt5"]["sip:module"].keys() ] if node.get("reftype") in type_translate_dict: type_names = type_translate_dict[node.get("reftype")] else: type_names = [node.get("reftype")] for name in type_names: obj_type_name = "sip:{}".format(name) if obj_type_name not in inventories.named_inventory["PyQt5"]: return None for target_name in target_list: if target_name in inventories.main_inventory[obj_type_name]: proj, version, uri, dispname = inventories.named_inventory["PyQt5"][ obj_type_name ][target_name] uri = uri.replace("##", "#") # print(node) # print nodes with unresolved references break else: continue break else: return None if app.config.qt_documentation == "Qt5": html_name = uri.split("/")[-1] uri = "https://doc.qt.io/qt-5/" + html_name if name == 'enum': uri += "-enum" elif app.config.qt_documentation == "PySide2": if node.get("reftype") == "meth": split_tup = target_name.split(".")[1:] ref_name = ".".join(["PySide2", split_tup[0], "PySide2"] + split_tup) html_name = "/".join(split_tup[:-1]) + ".html#" + ref_name else: html_name = "/".join(target_name.split(".")[1:]) + ".html" uri = "https://doc.qt.io/qtforpython/PySide2/" + html_name # remove this line if you would like straight to pyqt documentation if version: reftitle = _("(in %s v%s)") % (app.config.qt_documentation, version) else: reftitle = _("(in %s)") % (app.config.qt_documentation,) newnode = nodes.reference("", "", internal=False, refuri=uri, reftitle=reftitle) if node.get("refexplicit"): # use whatever title was given newnode.append(contnode) else: # else use the given display name (used for :ref:) newnode.append(contnode.__class__(dispname, dispname)) return newnode