def run(self):
     subprocess.call('sphinx-apidoc -f -o doc/source keystone',
                     shell=True)
     for builder in ['html', 'man']:
         self.builder = builder
         self.finalize_options()
         BuildDoc.run(self)

 def initialize_options(self):
     SphinxBuildDoc.initialize_options(self)
     self.clean_docs = False
     self.no_intersphinx = False
     self.open_docs_in_browser = False
     self.warnings_returncode = False
     self.traceback = False

 def run(self):
     # We need to create some assets in the source tree first...
     from robot.libdoc import libdoc
     out_file = os.path.join(self.source_dir, 'robot-doc.html')
     libdoc('DrupalLibrary::None', out_file)
     # ... before running the regular Sphinx builder
     BuildDoc.run(self)

 def run(self):
     base_dir = os.path.dirname(os.path.abspath(__file__))
     subprocess.Popen(["python", "generate_autodoc_index.py"], cwd=os.path.join(base_dir, "doc")).communicate()
     for builder in ["html", "man"]:
         self.builder = builder
         self.finalize_options()
         BuildDoc.run(self)

 def run(self):
     ret = subprocess.call(
         [sys.executable, sys.argv[0], 'build_ext', '-i']
     )
     if ret != 0:
         raise RuntimeError("Building Scipy failed!")
     SphinxBuildDoc.run(self)

 def run(self):
     src_dir = (self.distribution.package_dir or {'': ''})['']
     src_dir = os.path.join(os.getcwd(), src_dir)
     sphinx.apidoc.main(
         ['', '-f', '-o', os.path.join(self.source_dir, '_apidoc'),
          src_dir])
     BuildDoc.run(self)

    def run(self):
        """ Execute the build_sphinx command.

        The HTML and PDF docs will be included in the tarball. So this script
        MUST be executed before creating the distributable tarball.
        """

        # Build the Users Guide in HTML and TeX format
        for builder in ('html', 'pdf'):
            # Tidy up before every build
            try:
                os.remove(os.path.join(self.source_dir, 'index.rst'))
            except OSError:
                pass
            shutil.rmtree(self.doctree_dir, True)

            self.builder = builder
            self.builder_target_dir = os.path.join(self.build_dir, builder)
            self.mkpath(self.builder_target_dir)
            builder_index = 'index_{0}.txt'.format(builder)
            copy_file(os.path.join(self.source_dir, builder_index), 
                os.path.join(self.source_dir, 'index.rst'))
            BuildDoc.run(self)

        # Copy the docs to their final destination:
        # HTML docs (Users Guide and License) -> ./vitables/htmldocs
        # PDF guide -> ./doc
        output_dir = os.path.join("vitables", "htmldocs")
        if not os.access(output_dir, os.F_OK):
            # Include the HTML guide and the license in the package
            copy_tree(os.path.join(self.build_dir,"html"), output_dir)
            shutil.rmtree(os.path.join(output_dir,"_sources"))
            copy_file('LICENSE.html', output_dir)
        copy_file(os.path.join(self.build_dir, "pdf", 
            "UsersGuide.pdf"), "doc")

 def initialize_options(self):
     BuildDoc.initialize_options(self)
     self.update_gh_pages = False
     self.gh_origin_url = "[email protected]:ParaToolsInc/taucmdr.git"
     self.gh_user_name = None # Use github global conf
     self.gh_user_email = None # Use github global conf
     self.gh_commit_msg = "Updated documentation via build_sphinx"

        def run(self):

            # make sure the python path is pointing to the newly built
            # code so that the documentation is built on this and not a
            # previously installed version

            build = self.get_finalized_command('build')
            sys.path.insert(0, os.path.abspath(build.build_lib))

            # Copy gui files to the path:
            dst = os.path.join(os.path.abspath(build.build_lib), "pyFAI", "gui")
            if not os.path.isdir(dst):
                os.makedirs(dst)
            for i in os.listdir("gui"):
                if i.endswith(".ui"):
                    src = os.path.join("gui", i)
                    idst = os.path.join(dst, i)
                    if not os.path.exists(idst):
                        shutil.copy(src, idst)

            # Build the Users Guide in HTML and TeX format
            for builder in ('html', 'latex'):
                self.builder = builder
                self.builder_target_dir = os.path.join(self.build_dir, builder)
                self.mkpath(self.builder_target_dir)
                BuildDoc.run(self)
            sys.path.pop(0)

 def run(self):
     # Make sure the python path is pointing to the newly built
     # code so that the documentation is built on this and not a
     # previously installed version.
     build = self.get_finalized_command('build')
     sys.path.insert(0, os.path.abspath(build.build_lib))
     SphinxBuildDoc.run(self)
     sys.path.pop(0)

 def run(self):
     output_dir = os.path.join(__location__, "docs/_rst")
     module_dir = os.path.join(__location__, MAIN_PACKAGE)
     cmd_line_template = "sphinx-apidoc -f -o {outputdir} {moduledir}"
     cmd_line = cmd_line_template.format(outputdir=output_dir,
                                         moduledir=module_dir)
     apidoc.main(cmd_line.split(" "))
     BuildDoc.run(self)

 def run(self):
     if self.update_gh_pages:
         self._clone_gh_pages()
     self._copy_docs_source()
     self._generate_api_docs()
     BuildDoc.run(self)
     if self.update_gh_pages:
         self._push_gh_pages()

 def run(self):
     # in place build
     ret = subprocess.call([sys.executable, sys.argv[0], 'build_ext', '-i'])
     if ret != 0:
         raise RuntimeError("Building atoman failed (%d)" % ret)
     
     # build doc
     BuildDoc.run(self)

 def initialize_options(self):
     BuildDoc.initialize_options(self)
     # Fix up defaults for option dicts
     build_doc = self.distribution.get_option_dict("build_sphinx")
     if "source_dir" not in build_doc:
         self.source_dir = "doc/source"
     if "build_dir" not in build_doc:
         self.build_dir = "doc/build"
     self.all_files = False

 def run(self):
     self.run_command('api_docs')
     # We need to be in the doc directory for to plot_directive
     # and API generation to work
     os.chdir('doc')
     try:
         BuildDoc.run(self)
     finally:
         os.chdir('..')
     self.zip_docs()

 def run(self):
     build = self.get_finalized_command('build')
     sys.path.insert(0, os.path.abspath(build.build_lib))
     self.builder_target_dir = 'build/doc/{0}/doc'.format(DISTNAME)
     BuildDoc.user_options
     try:
         BuildDoc.run(self)
     except UnicodeDecodeError:
         print >>sys.stderr, "ERROR: unable to build documentation because Sphinx do not handle source path with non-ASCII characters. Please try to move the source package to another location (path with *only* ASCII characters)."
     sys.path.pop(0)

 def run(self):
     if self.builder == "doctest":
         import sphinx.ext.doctest as doctest
         # Capture the DocTestBuilder class in order to return the total
         # number of failures when exiting
         ref = capture_objs(doctest.DocTestBuilder)
         BuildDoc.run(self)
         errno = ref[-1].total_failures
         sys.exit(errno)
     else:
         BuildDoc.run(self)

            def run(self):
                if not os.getenv('SPHINX_DEBUG'):
                    self.generate_autoindex()

                for builder in ['html', 'man']:
                    self.builder = builder
                    self.finalize_options()
                    self.project = self.distribution.get_name()
                    self.version = self.distribution.get_version()
                    self.release = self.distribution.get_version()
                    BuildDoc.run(self)

        def run(self):
            # make sure the python path is pointing to the newly built
            # code so that the documentation is built on this and not a
            # previously installed version

            build = self.get_finalized_command('build')
            sys.path.insert(0, os.path.abspath(build.build_lib))
            # we need to reload PyMca from the build directory and not
            # the one from the source directory which does not contain
            # the extensions
            BuildDoc.run(self)
            sys.path.pop(0)

        def run(self):

            """ Execute the build_sphinx command.

            The HTML and PDF docs are included in the tarball. So even if 
            sphinx or pdflatex are not installed on the user's system she will 
            get the full documentation installed when installing ViTables in 
            the usual way::

                # python setup.py install

            because the build_sphinx command will not be executed by default.

            If user is installing from a binary package (which will not include
            the docs, I think), in order to ensure that she will always end up with
            the docs being installed, the package should depend on the sphinx and
            pdflatex packages and the `sphinx_found` variable should be set to 
            True.
            """

            # Build the Users Guide in HTML and TeX format
            for builder in ('html', 'latex'):
                # Tidy up before every build
                try:
                    os.remove(os.path.join(self.source_dir, 'index.rst'))
                except OSError:
                    pass
                shutil.rmtree(self.doctree_dir, True)

                self.builder = builder
                self.builder_target_dir = os.path.join(self.build_dir, builder)
                self.mkpath(self.builder_target_dir)
                builder_index = 'index_{0}.txt'.format(builder)
                copy_file(os.path.join(self.source_dir, builder_index), 
                    os.path.join(self.source_dir, 'index.rst'))
                BuildDoc.run(self)

            # Build the Users Guide in PDF format
            builder_latex_dir = os.path.join(self.build_dir, 'latex')
            make_path = find_executable("make")
            spawn([make_path, "-C", builder_latex_dir, "all-pdf"])

            # Copy the docs to their final destination:
            # HTML docs (Users Guide and License) -> ./vitables/htmldocs
            # PDF guide -> ./doc
            output_dir = os.path.join("vitables", "htmldocs")
            if not os.access(output_dir, os.F_OK):
                # Include the HTML guide and the license in the package
                copy_tree(os.path.join(self.build_dir,"html"), output_dir)
                shutil.rmtree(os.path.join(output_dir,"_sources"))
                copy_file('LICENSE.html', output_dir)
            copy_file(os.path.join(builder_latex_dir, 
                "UsersGuide.pdf"), "doc")