Python pydoc.getdoc函数代码示例

    def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc,
                 config={}):
        if not inspect.isclass(cls) and cls is not None:
            raise ValueError("Expected a class or None, but got %r" % cls)
        self._cls = cls

        if modulename and not modulename.endswith('.'):
            modulename += '.'
        self._mod = modulename

        if doc is None:
            if cls is None:
                raise ValueError("No class or documentation string given")
            doc = pydoc.getdoc(cls)

        NumpyDocString.__init__(self, doc)

        if config.get('show_class_members', True):
            def splitlines_x(s):
                if not s:
                    return []
                else:
                    return s.splitlines()

            for field, items in [('Methods', self.methods),
                                 ('Attributes', self.properties)]:
                if not self[field]:
                    doc_list = []
                    for name in sorted(items):
                         try:
                            doc_item = pydoc.getdoc(getattr(self._cls, name))
                            doc_list.append((name, '', splitlines_x(doc_item)))
                         except AttributeError:
                            pass # method doesn't exist
                    self[field] = doc_list

 def hh(cmd = None):
     """Get help on a command."""
     shell_funcs['hh'] = hh
     import pydoc
     from inspect import getargspec, formatargspec
     if not cmd:
         print "\nUse self.addrspace for Kernel/Virtual AS"
         print "Use self.addrspace.base for Physical AS"
         print "Use self.proc to get the current _EPROCESS object"
         print "  and self.proc.get_process_address_space() for the current process AS"
         print "  and self.proc.get_load_modules() for the current process DLLs\n"
         for f in sorted(shell_funcs):
             doc = pydoc.getdoc(shell_funcs[f])
             synop, _full = pydoc.splitdoc(doc)
             print "{0:40} : {1}".format(f + formatargspec(*getargspec(shell_funcs[f])), synop)
         print "\nFor help on a specific command, type 'hh(<command>)'"
     elif type(cmd) == str:
         try:
             doc = pydoc.getdoc(shell_funcs[cmd])
         except KeyError:
             print "No such command: {0}".format(cmd)
             return
         print doc
     else:
         doc = pydoc.getdoc(cmd)
         print doc

def h(cmd=None):
    if cmd:
        L = [cmd,]
    else:
        L = cmds[:]

    for x in L:
        print x
        print pydoc.getdoc(eval(x))

 def __init__(self, provider, permission, signatures, callable, name = None):
     """ Accept a signature in the form returned by xmlrpc_methods. """
     import pydoc
     self.permission = permission
     self.callable = callable
     self.rpc_signatures = signatures
     self.description = pydoc.getdoc(callable)
     if name is None:
         self.name = provider.xmlrpc_namespace() + '.' + callable.__name__
     else:
         self.name = provider.xmlrpc_namespace() + '.' + name
     self.namespace = provider.xmlrpc_namespace()
     self.namespace_description = pydoc.getdoc(provider)

def mangle_signature(app, what, name, obj, options, sig, retann):
    # Do not try to inspect classes that don't define `__init__`
    if (inspect.isclass(obj) and
        'initializes x; see ' in pydoc.getdoc(obj.__init__)):
        return '', ''

    if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return
    if not hasattr(obj, '__doc__'): return

    doc = SphinxDocString(pydoc.getdoc(obj))
    if doc['Signature']:
        sig = re.sub("^[^(]*", "", doc['Signature'])
        return sig, ''

    def docroutine(self, obj, name=None, mod=None, cl=None):
        """Produce text documentation for a function or method obj."""
        realname = obj.__name__
        name = name or realname
        note = ''
        skipdocs = 0
        if inspect.ismethod(obj):
            obj = obj.__func__
        if name == realname:
            title = self.bold(realname)
        else:
            if cl and realname in cl.__dict__ and cl.__dict__[realname] is obj:
                skipdocs = 1
            title = '%s = %s' % (self.bold(name), realname)
        if inspect.isfunction(obj):
            args, varargs, keywords, defaults = inspect.getargspec(obj)
            argspec = inspect.formatargspec(args, varargs, keywords, defaults, formatvalue=self.formatvalue)

        else:
            argspec = '(...)'
        decl = "def %s(%s'):\n{: .lead}%s" % (title, escape_equal(self.emphasis(argspec[1:-1])), note)
        if skipdocs:
            return decl + '\n'
        else:
            doc = pydoc.getdoc(obj) or ''
            return '%s\n> %s' % (decl, (doc and self.indent(doc).rstrip() + '\n'))

    def pprinthook(value):
        """Pretty print an object to sys.stdout and also save it in
        __builtin__.
        """

        if value is None:
            return
        __builtin__._ = value

        if isinstance(value, help_types):
            reprstr = repr(value)
            try:
                if inspect.isfunction(value):
                    parts = reprstr.split(' ')
                    parts[1] += inspect.formatargspec(*getargspec(value))
                    reprstr = ' '.join(parts)
                elif inspect.ismethod(value):
                    parts = reprstr[:-1].split(' ')
                    parts[2] += inspect.formatargspec(*getargspec(value))
                    reprstr = ' '.join(parts) + '>'
            except TypeError:
                pass
            sys.stdout.write(reprstr)
            sys.stdout.write('\n')
            if getattr(value, '__doc__', None):
                sys.stdout.write('\n')
                sys.stdout.write(pydoc.getdoc(value))
                sys.stdout.write('\n')
        else:
            pphighlight(value, width=get_width() or 80)

    def run(self):
        prefix = self.arguments and self.arguments.pop() or None
        content = []
        for resource_type, resource_classes in _filter_resources(
                prefix, self.path(), self.statuses()):
            for resource_class in resource_classes:
                self.resource_type = resource_type
                self.resource_class = resource_class
                section = self._section(content, resource_type, '%s')

                self.props_schemata = properties.schemata(
                    self.resource_class.properties_schema)
                self.attrs_schemata = attributes.schemata(
                    self.resource_class.attributes_schema)

                self._status_str(resource_class.support_status, section)

                cls_doc = pydoc.getdoc(resource_class)
                if cls_doc:
                    # allow for rst in the class comments
                    cls_nodes = core.publish_doctree(cls_doc).children
                    section.extend(cls_nodes)

                self.contribute_properties(section)
                self.contribute_attributes(section)

                self.contribute_hot_syntax(section)
                self.contribute_yaml_syntax(section)
                self.contribute_json_syntax(section)

        return content

    def run(self):
        prefix = self.arguments and self.arguments.pop() or None
        content = []
        for resource_type, resource_classes in _filter_resources(prefix, self.path(), self.statuses()):
            for resource_class in resource_classes:
                self.resource_type = resource_type
                self.resource_class = resource_class
                section = self._section(content, resource_type, "%s")

                self.props_schemata = properties.schemata(self.resource_class.properties_schema)
                self.attrs_schemata = attributes.schemata(self.resource_class.attributes_schema)
                # NOTE(prazumovsky): Adding base_attributes_schema dict to
                # Resource class should means adding new attributes from this
                # dict to documentation of each resource, else there is no
                # chance to learn about base attributes.
                self.attrs_schemata.update(self.resource_class.base_attributes_schema)
                self.update_policy_schemata = properties.schemata(self.resource_class.update_policy_schema)

                self._status_str(resource_class.support_status, section)

                cls_doc = pydoc.getdoc(resource_class)
                if cls_doc:
                    # allow for rst in the class comments
                    cls_nodes = core.publish_doctree(cls_doc).children
                    section.extend(cls_nodes)

                self.contribute_properties(section)
                self.contribute_attributes(section)
                self.contribute_update_policy(section)

                self.contribute_hot_syntax(section)

        return content

def get_doc_object(obj, what=None, doc=None, config={}):

    if what is None:
        if inspect.isclass(obj):
            what = 'class'
        elif inspect.ismodule(obj):
            what = 'module'
        elif isinstance(obj, collections.Callable):
            what = 'function'
        else:
            what = 'object'

    if what == 'class':
        # It is important that the `doc=doc` is passed because
        # this function may be run the second time with a
        # prepared docstring `doc` and `obj=None`
        # In that case the prepared `doc` is used
        newdoc = SphinxTraitsDoc(obj, "", func_doc=SphinxFunctionDoc,
                                 doc=doc, config=config)
        if obj and looks_like_issubclass(obj, "HasTraits"):
            for name, trait, comment in comment_eater.get_class_traits(obj):
                # Exclude private traits.
                if not name.startswith('_'):
                    newdoc['Traits'].append((name, trait, comment.splitlines()))
        return newdoc
    elif what in ('function', 'method'):
        return SphinxFunctionDoc(obj, doc=doc, config=config)
    else:
        if doc is None and obj:
            doc = pydoc.getobj(obj)
        return SphinxDocString(pydoc.getdoc(obj), config=config)

def main():
    usage = __import__(__name__).__doc__.strip()
    usage += "\n\nCommands:\n\n"
    commands = {}
    for func in sorted(COMMANDS):
        name = func.__name__.strip().replace("cmd_", "").replace("_", "-")
        commands[name] = func
        head, tail = pydoc.splitdoc(pydoc.getdoc(func))
        cmd_help = textwrap.fill(tail, width=70).replace("\n", "\n    ").strip()
        usage += "%s\n    %s\n\n" % (head, cmd_help)
    usage = usage.strip()

    parser = OptionParser(usage=usage)
    parser.allow_interspersed_args = False
    (options, args) = parser.parse_args()

    if len(args) < 1:
        parser.error("No command given")

    cmd_name = args.pop(0)
    cmd = commands.get(cmd_name)

    if cmd is None:
        parser.error("Unknown command %s" % cmd_name)
    else:
        cmd(args)

    def docclass(self, object, name=None, mod=None):
        ''' Produce text documentation for a given class object.
        '''
        realname = object.__name__
        name = name or realname
        bases = object.__bases__

        if name == realname:
            title = '### class ' + self.bold(realname)
        else:
            title = '### ' + self.bold(name) + ' = class ' + realname
        if bases:
            def makename(c, m=object.__module__): return pydoc.classname(c, m)
            parents = map(makename, bases)
            title = title + '(%s)' % ', '.join(parents)

        doc = pydoc.getdoc(object)
        contents = doc and doc + '\n'
        methods = pydoc.allmethods(object).items()
        methods.sort()
        for key, value in methods:
            if key.startswith('_'):
                continue    
            contents = contents + '\n' + self.document(value, key, mod, object)

        if not contents: return title + '\n'
        return title + '\n' + self.indent(contents.rstrip()) + '\n'

    def doc_element(self, element, namespace, qname):
        """
        Document extension elements
        """
        attributes = {'namespace-uri' : namespace or '',
                      'name' : qname,
                      }
        self.start_element('element', attributes)

        desc = self.escape(pydoc.getdoc(element))
        self.write_element('description', content=desc)

        if element.content:
            content  = self.escape(str(element.content))
            self.write_element('content', content=content)

        attributes = element.legalAttrs or {}
        for name, info in attributes.items():
            attrs = {'name' : name,
                     'content' : str(info),
                     'required' : info.required and 'yes' or 'no',
                     }
            if info.default:
                attrs['default'] = info.default
            self.start_element('attribute', attrs)
            desc = info.description or ''
            self.write_element('description', content=desc)
            self.end_element('attribute')

        self.end_element('element')
        return

def setup(args=None):
    # make sure our directory is at the front of sys.path
    module = metadata('backupmgr')

    # get the version and description from the source
    version = module.__version__
    description = pydoc.splitdoc(pydoc.getdoc(module))[0]
    author, author_email = email.utils.parseaddr(module.__authors__[0])

    # get the long description from README-type files
    long_description = []
    for path in READMES:
        with open(os.path.join(SRCROOT, path), 'r') as fh:
            long_description.append(fh.read())
    long_description = '\n'.join([ x for x in long_description if x ])
    # use setuptools to do the rest
    setuptools.setup(
        name=pkg_resources.safe_name(module.__name__),
        packages=setuptools.find_packages(),
        version=version,
        description=description,
        author=author,
        author_email=author_email,
        zip_safe=True,
        #url=None,
        install_requires=["python-dateutil"],
        long_description=long_description,
        license='BSD',
        classifiers=[
            'Development Status :: 3 - Alpha',
            'Intended Audience :: Developers'
        ])

 def write_doc(self, file):
     file.write(str(self.entry.home) + "\n")
     doc = pydoc.getdoc(self.entry.home)
     if doc:
         file.write(doc + "\n")
     for field in str(self.entry.info).split(', '):
         file.write("\t" + field + "\n")