Did I find the right examples for you? yes no

All Samples(25)  |  Call(13)  |  Derive(0)  |  Import(12)

        def main(args):
    import cPickle
    options, args = parse_args(args)

    exitcode = 0

    if options.configfile:
        readConfigFile(options)

    try:
        # step 1: make/find the system
        if options.systemclass:
            systemclass = findClassFromDottedName(options.systemclass,
                                                  '--system-class')
            if not issubclass(systemclass, model.System):
                msg = "%s is not a subclass of model.System"
                error(msg, systemclass)
        else:
            systemclass = zopeinterface.ZopeInterfaceSystem

        if options.inputpickle:
            system = cPickle.load(open(options.inputpickle, 'rb'))
            if options.systemclass:
                if type(system) is not systemclass:
                    cls = type(system)
                    msg = ("loaded pickle has class %s.%s, differing "
                           "from explicitly requested %s")
                    error(msg, cls.__module__, cls.__name__,
                          options.systemclass)
        else:
            system = systemclass()

        system.options = options

        system.urlprefix = ''
        if options.moresystems:
            moresystems = []
            for fnamepref in options.moresystems:
                fname, prefix = fnamepref.split(':', 1)
                moresystems.append(cPickle.load(open(fname, 'rb')))
                moresystems[-1].urlprefix = prefix
                moresystems[-1].options = system.options
                moresystems[-1].subsystems.append(system)
            system.moresystems = moresystems
        system.sourcebase = options.htmlsourcebase

        if options.abbrevmapping:
            for thing in options.abbrevmapping.split(','):
                k, v = thing.split('=')
                system.abbrevmapping[k] = v

        # step 1.5: check that we're actually going to accomplish something here

        if options.auto:
            options.server = True
            options.edit = True
            for fn in os.listdir('.'):
                if os.path.isdir(fn) and \
                   os.path.exists(os.path.join(fn, '__init__.py')):
                    options.packages.append(fn)
                elif fn.endswith('.py') and fn != 'setup.py':
                    options.modules.append(fn)

        args = list(args) + options.modules + options.packages

        if options.makehtml == MAKE_HTML_DEFAULT:
            if not options.outputpickle and not options.testing \
                   and not options.server:
                options.makehtml = True
            else:
                options.makehtml = False

        # step 2: add any packages and modules

        if args:
            prependedpackage = None
            if options.prependedpackage:
                for m in options.prependedpackage.split('.'):
                    prependedpackage = system.Package(
                        system, m, None, prependedpackage)
                    system.addObject(prependedpackage)
                    initmodule = system.Module(system, '__init__', None, prependedpackage)
                    system.addObject(initmodule)
            for path in args:
                path = os.path.abspath(path)
                if path in system.packages:
                    continue
                if os.path.isdir(path):
                    system.msg('addPackage', 'adding directory ' + path)
                    system.addPackage(path, prependedpackage)
                else:
                    system.msg('addModuleFromPath', 'adding module ' + path)
                    system.addModuleFromPath(prependedpackage, path)
                system.packages.append(path)

        # step 3: move the system to the desired state

        if not system.packages:
            error("The system does not contain any code, did you "
                  "forget an --add-package?")

        system.process()

        if system.options.livecheck:
            error("write this")

        if system.options.projectname is None:
            name = '/'.join([ro.name for ro in system.rootobjects])
            system.msg(
                'warning',
                'WARNING: guessing '+name+' for project name', thresh=-1)
            system.guessedprojectname = name

        # step 4: save the system, if desired

        if options.outputpickle:
            system.msg('', 'saving output pickle to ' + options.outputpickle)
            del system.options # don't persist the options
            f = open(options.outputpickle, 'wb')
            cPickle.dump(system, f, cPickle.HIGHEST_PROTOCOL)
            f.close()
            system.options = options

        # step 5: make html, if desired

        if options.makehtml:
            if options.htmlwriter:
                writerclass = findClassFromDottedName(
                    options.htmlwriter, '--html-writer')
            else:
                from pydoctor import templatewriter
                writerclass = templatewriter.TemplateWriter

            system.msg('html', 'writing html to %s using %s.%s'%(
                options.htmloutput, writerclass.__module__,
                writerclass.__name__))

            writer = writerclass(options.htmloutput)
            writer.system = system
            writer.prepOutputDirectory()

            system.epytextproblems = []

            if options.htmlsubjects:
                subjects = []
                for fn in options.htmlsubjects:
                    subjects.append(system.allobjects[fn])
            elif options.htmlsummarypages:
                writer.writeModuleIndex(system)
                subjects = []
            else:
                writer.writeModuleIndex(system)
                subjects = system.rootobjects
            writer.writeIndividualFiles(subjects, options.htmlfunctionpages)
            if system.epytextproblems:
                def p(msg):
                    system.msg(('epytext', 'epytext-summary'), msg, thresh=-1, topthresh=1)
                p("these %s objects' docstrings are not proper epytext:"
                  %(len(system.epytextproblems),))
                exitcode = 2
                for fn in system.epytextproblems:
                    p('    '+fn)
            if options.outputpickle:
                system.msg(
                    '', 'saving output pickle to ' + options.outputpickle)
                # save again, with epytextproblems
                del system.options # don't persist the options
                f = open(options.outputpickle, 'wb')
                cPickle.dump(system, f, cPickle.HIGHEST_PROTOCOL)
                f.close()
                system.options = options

        # Finally, if we should serve html, lets serve some html.
        if options.server:
            from pydoctor.server import (
                EditingPyDoctorResource, PyDoctorResource)
            from pydoctor.epydoc2stan import doc2stan
            from twisted.web.server import Site
            from twisted.web.resource import Resource
            from twisted.web.vhost import VHostMonsterResource
            from twisted.internet import reactor
            if options.edit:
                if not options.nocheck:
                    system.msg(
                        "server", "Checking formatting of docstrings.")
                    included_obs = [
                        ob for ob in system.orderedallobjects
                        if ob.isVisible]
                    for i, ob in enumerate(included_obs):
                        system.progress(
                            "server", i+1, len(included_obs),
                            "docstrings checked, found %s problems" % (
                            len(system.epytextproblems)))
                        doc2stan(ob, docstring=ob.docstring)
                root = EditingPyDoctorResource(system)
            else:
                root = PyDoctorResource(system)
            if options.facing_path:
                options.local_only = True
                realroot = Resource()
                cur = realroot
                realroot.putChild('vhost', VHostMonsterResource())
                segments = options.facing_path.split('/')
                for segment in segments[:-1]:
                    next = Resource()
                    cur.putChild(segment, next)
                    cur = next
                cur.putChild(segments[-1], root)
                root = realroot
            system.msg(
                "server",
                "Setting up server at http://localhost:%d/" %
                options.server_port)
            if options.auto:
                def wb_open():
                    import webbrowser
                    webbrowser.open(
                        'http://localhost:%d/' % options.server_port)
                reactor.callWhenRunning(wb_open)
            from twisted.python import log
            log.startLogging(sys.stdout)
            site = Site(root)
            if options.local_only:
                interface = 'localhost'
            else:
                interface = ''
            reactor.listenTCP(options.server_port, site, interface=interface)
            reactor.run()
    except:
        if options.pdb:
            import pdb
            pdb.post_mortem(sys.exc_traceback)
        raise
    return exitcode
        


src/h/o/hortonworks-sandbox-HEAD/desktop/core/ext-py/Twisted/twisted/python/_release.py   hortonworks-sandbox(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/o/h/oh-mainline-HEAD/vendor/packages/twisted/twisted/python/_release.py   oh-mainline(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/m/y/mythbox-HEAD/resources/lib/twisted/twisted/python/_release.py   mythbox(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/p/y/pymodbus-HEAD/doc/api/pydoctor/build.py   pymodbus(Download)
    pkg_resources.require("pydoctor")
 
    from pydoctor.driver import main
    sys.argv = '''pydoctor.py --quiet
        --project-name=Pymodbus
 
    print "Building Pydoctor API Documentation"
    main(sys.argv[1:])
 
    if os.path.exists('../../../build'):

src/s/u/SubliminalCollaborator-HEAD/libs/twisted/python/_release.py   SubliminalCollaborator(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/b/l/blockBox-HEAD/lib/twisted/python/_release.py   blockBox(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/p/y/PythonForumIDE-HEAD/pythonforumide/twisted/python/_release.py   PythonForumIDE(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/t/w/Twisted-13.2.0/twisted/python/_release.py   Twisted(Download)
            documentation will be written.
        """
        from pydoctor.driver import main
        main(
            ["--project-name", projectName,

src/f/i/fixture-1.5/fixture/setup_cmd/apidocs.py   fixture(Download)
            os.mkdir(docs.builddir)
        docs.state_is_api = True
        from pydoctor.driver import main
        argv = [
            '--html-output=%s/apidocs' % docs.builddir, '--project-name=fixture', 
 
        sys.argv[0] = ['pydoctor'] # can't remember why
        main(argv)

src/f/i/fixture-HEAD/fixture/setup_cmd/apidocs.py   fixture(Download)
            os.mkdir(docs.builddir)
        docs.state_is_api = True
        from pydoctor.driver import main
        argv = [
            '--html-output=%s/apidocs' % docs.builddir, '--project-name=fixture', 
 
        sys.argv[0] = ['pydoctor'] # can't remember why
        main(argv)

  1 | 2  Next