コード例 #1
0
ファイル: volshell.py プロジェクト: B-Rich/amark
 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
コード例 #2
0
ファイル: docscrape.py プロジェクト: AlexandreAbraham/nilearn
    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
コード例 #3
0
ファイル: werk.py プロジェクト: gregglind/werk
def h(cmd=None):
    if cmd:
        L = [cmd,]
    else:
        L = cmds[:]

    for x in L:
        print x
        print pydoc.getdoc(eval(x))
コード例 #4
0
ファイル: api.py プロジェクト: Puppet-Finland/trac
 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)
コード例 #5
0
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, ''
コード例 #6
0
ファイル: pydoc-tool.py プロジェクト: pv/pydocweb
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)
コード例 #7
0
ファイル: pydoc2md.py プロジェクト: ownport/pydoc2md
    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'
コード例 #8
0
    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
コード例 #9
0
ファイル: pybdsm.py プロジェクト: saiyanprince/pyimager
 def help(self, request):
     global _img
     topbar = '_' * 72 + '\n' # 72-character divider
     if hasattr(request, '__name__'):
         pydoc.pager(topbar + 'Help on ' + pydoc.text.bold(request.__name__)
                     + ':\n\n' + pydoc.getdoc(request))
     else:
         opts = _img.opts.__class__.__dict__
         try:
             opt = opts[request]
             desc_list = str(opt.doc()).split('\n')
             desc = '\n\n'.join(desc_list)
             default_val = opt._default
             if isinstance(default_val, str):
                 valstr = "'" + default_val + "'"
             else:
                 valstr = str(default_val)
             default_val_text = 'Default value: ' + valstr
             if opt.group() != None and opt.group() != 'hidden':
                 group_text = '\nBelongs to group: ' + opt.group()
             else:
                 group_text = ''
             desc_text = lofar.bdsm.interface.wrap(desc, 72)
             desc_text = '\n'.join(desc_text)
             pydoc.pager(topbar + 'Help on the ' + pydoc.text.bold(request)
                         + ' parameter:\n\n' + default_val_text
                         + group_text
                         + '\n\n' + desc_text)
         except(KeyError):
             print "Parameter '" + request + "' not recognized."
コード例 #10
0
ファイル: .pythonrc.py プロジェクト: Le-Stagiaire/conf
    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)
コード例 #11
0
ファイル: setup.py プロジェクト: theg5prank/backupmgr
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'
        ])
コード例 #12
0
ファイル: pydoc_markdown.py プロジェクト: tmthydvnprt/utilipy
    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'))
コード例 #13
0
ファイル: metareview.py プロジェクト: zaneb/metareview
def main():
    """Run the metareview command-line interface."""

    import optparse
    import pydoc

    docstring = pydoc.getdoc(sys.modules[__name__])

    optparser = optparse.OptionParser(usage="%prog [-p PROJECT] [-u SSH_USER] "
                                            "[-s SSH_SERVER] REVIEWER",
                                      description=docstring)
    optparser.add_option('-p', '--project', default='openstack/heat',
                         help='The project to look in. '
                              'Defaults to "%default".')
    optparser.add_option('-u', '--ssh-user', default=None,
                         help='The Gerrit username to connect with.')
    optparser.add_option('-s', '--ssh-server', default='review.openstack.org',
                         help='The Gerrit server to connect to. '
                              'Defaults to "%default".')

    options, args = optparser.parse_args()

    if len(args) < 1:
        raise Exception('No reviewer specified.')

    if len(args) > 1:
        raise Exception('Multiple reviewers specified.')

    return metareview(options, args[0], sys.stdout)
コード例 #14
0
    def system_methodHelp(self, method_name):
        """system.methodHelp('add') => "Adds two integers together"

        Returns a string containing documentation for the specified method."""

        method = None
        if self.funcs.has_key(method_name):
            method = self.funcs[method_name]
        elif self.instance is not None:
            # Instance can implement _methodHelp to return help for a method
            if hasattr(self.instance, '_methodHelp'):
                return self.instance._methodHelp(method_name)
            # if the instance has a _dispatch method then we
            # don't have enough information to provide help
            elif not hasattr(self.instance, '_dispatch'):
                try:
                    method = resolve_dotted_attribute(
                                self.instance,
                                method_name,
                                self.allow_dotted_names
                                )
                except AttributeError:
                    pass

        # Note that we aren't checking that the method actually
        # be a callable object of some kind
        if method is None:
            return ""
        else:
            import pydoc
            return pydoc.getdoc(method)
コード例 #15
0
ファイル: traitsdoc.py プロジェクト: PeterZhouSZ/mayavi
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)
コード例 #16
0
ファイル: ApiFormatter.py プロジェクト: flaub/Peach
    def doc_arguments(self, object):
        self.start_element("arguments")

        if inspect.isfunction(object):
            args, varargs, varkw, defaults = inspect.getargspec(object)

            if defaults:
                firstdefault = len(args) - len(defaults)

            for i in xrange(len(args)):
                if defaults and i >= firstdefault:
                    default = repr(defaults[i - firstdefault])
                else:
                    default = None
                self.format_arg(args[i], default)

            if varargs:
                self.write_element("var-args", {"name": varargs})

            if varkw:
                self.write_element("var-keywords", {"name": varkw})
        else:
            arglist = "..."
            if inspect.isbuiltin(object):
                # Extract argument list from docstring
                match = _re_arglist.match(pydoc.getdoc(object))
                if match:
                    arglist = match.group("arglist")
            self.write_element("unknown", content=arglist)

        self.end_element("arguments")
        return
コード例 #17
0
ファイル: docscrape.py プロジェクト: PaulPrice/healpy
    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

        self._exclude_class_members = config.get('exclude_class_members', [])

        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):
            if not self['Methods']:
                self['Methods'] = [(name, '', '')
                                   for name in sorted(self.methods)]
            if not self['Attributes']:
                self['Attributes'] = [(name, '', '')
                                      for name in sorted(self.properties)]
コード例 #18
0
ファイル: docscrape.py プロジェクト: AndreaEdwards/scikit-bio
 def methods(self):
     if self._cls is None:
         return []
     return [name for name,func in inspect.getmembers(self._cls)
             if ((not name.startswith('_') or
                  '.. shownumpydoc' in pydoc.getdoc(func))
                 and isinstance(func, collections.Callable))]
コード例 #19
0
ファイル: case.py プロジェクト: TimSimpsonR/python-proboscis
 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")
コード例 #20
0
ファイル: models.py プロジェクト: SivagnanamCiena/lava-server
    def methodHelp(self, method_name):
        """
        Name
        ----
        `methodHelp` (`method_name`)

        Description
        -----------
        Provide documentation for specified method.

        Arguments
        ---------
        `method_name`: string
            Name of the method whose documentation is required.

        Return value
        ------------
        Returns the documentation for specified method.
        """
        impl = self._context.mapper.lookup(method_name, self._context)
        if impl is None:
            return ""
        else:
            import pydoc
            return pydoc.getdoc(impl)
コード例 #21
0
def process_routine(rootElt, obj, name, callables):    
    if inspect.isfunction(obj):
        if _gIsPy3:
            argspec = inspect.getfullargspec(obj)
        else:
            argspec = inspect.getargspec(obj)
        sig = name + inspect.formatargspec(*argspec)
    else:
        sig = ''
    doc = getdoc(obj) or None
    call_sig_lines, description_lines = parsePyFuncDoc(doc, [sig])
    if description_lines:
        doc = '\n'.join(parseDocSummary(description_lines))
    if call_sig_lines:
        signature = '\n'.join(call_sig_lines)
    else:
        signature = sig
    if name == '__init__':
        if doc == obj.__init__.__doc__:
            doc = None
        if signature == obj.__init__.__doc__:
            signature = None
    
    funcElt = SubElement(rootElt, "scope", ilk="function", name=name)
    if doc: funcElt.set('doc', doc)
    if signature: funcElt.set('signature', signature)

    callables[name] = funcElt
コード例 #22
0
ファイル: recipe-576733.py プロジェクト: jacob-carrier/code
	def docroutine(self, object, name=None, mod=None, cl=None):
		"""Produce text documentation for a function or method object."""
		realname = object.__name__
		name = name or realname
		note = ''
		skipdocs = 0
		if inspect.ismethod(object):
			object = object.__func__
		if name == realname:
			title = self.bold(realname)
		else:
			if (cl and realname in cl.__dict__ and cl.__dict__[realname] is object):
				skipdocs = 1
			title = self.bold(name) + ' = ' + realname
		if inspect.isfunction(object):
			args, varargs, varkw, defaults, kwonlyargs, kwdefaults, ann = inspect.getfullargspec(object)
			argspec = inspect.formatargspec(
				args, varargs, varkw, defaults, kwonlyargs, kwdefaults, ann,
				formatvalue=self.formatvalue,
				formatannotation=inspect.formatannotationrelativeto(object))
			if realname == '<lambda>':
				title = self.bold(name) + ' lambda '
				# XXX lambda's won't usually have func_annotations['return']
				# since the syntax doesn't support but it is possible.
				# So removing parentheses isn't truly safe.
				argspec = argspec[1:-1] # remove parentheses
		else:
			argspec = '(...)'
		decl = "#### " + "def " + title + argspec + ':' + '\n' + note

		if skipdocs:
			return decl + '\n'
		else:
			doc = pydoc.getdoc(object) or ''
			return decl + '\n' + (doc and self.indent(doc).rstrip() + '\n')
コード例 #23
0
ファイル: gord.py プロジェクト: angvp/gord
  def Help(self, method=None):
    """Return help/usage information on a method.

    Args:
      method: string name like "GetUsageDataByHost"
    Returns:
      HTML documentat
    """
    if method is None:
      obj = self
      title = 'GORD Help'
      text = 'This is the GORD server.'
    else:
      if method.startswith('_') or not hasattr(self, method):
        raise common.InvalidMethod(method)
      title = method
      obj = getattr(self, method)
      text = pydoc.getdoc(obj)

    other = ['Other Help:']
    methods = dir(self)
    methods.sort()
    for d in methods:
      if d.startswith('_') or type(getattr(self, d)) is not types.MethodType:
        continue
      other.append('  %s' % d)
    footer = '\n'.join(other)
    return '%s\n\n%s\n\n%s\n\n' % (title, text, footer)
コード例 #24
0
ファイル: server.py プロジェクト: Apoorvadabhere/cpython
    def docroutine(self, object, name, mod=None,
                   funcs={}, classes={}, methods={}, cl=None):
        """Produce HTML documentation for a function or method object."""

        anchor = (cl and cl.__name__ or '') + '-' + name
        note = ''

        title = '<a name="%s"><strong>%s</strong></a>' % (
            self.escape(anchor), self.escape(name))

        if callable(object):
            argspec = str(signature(object))
        else:
            argspec = '(...)'

        if isinstance(object, tuple):
            argspec = object[0] or argspec
            docstring = object[1] or ""
        else:
            docstring = pydoc.getdoc(object)

        decl = title + argspec + (note and self.grey(
               '<font face="helvetica, arial">%s</font>' % note))

        doc = self.markup(
            docstring, self.preformat, funcs, classes, methods)
        doc = doc and '<dd><tt>%s</tt></dd>' % doc
        return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
コード例 #25
0
ファイル: resources.py プロジェクト: AnyBucket/heat
    def run(self):
        prefix = self.arguments and self.arguments.pop() or None
        content = []
        for resource_type, resource_class in _all_resources(prefix):
            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)

            if resource_class.support_status.status == support.DEPRECATED:
                sstatus = resource_class.support_status.to_dict()
                msg = _('%(status)s')
                if sstatus['message'] is not None:
                    msg = _('%(status)s - %(message)s')
                para = nodes.inline('', msg % sstatus)
                warning = nodes.note('', para)
                section.append(warning)

            cls_doc = pydoc.getdoc(resource_class)
            if cls_doc:
                para = nodes.paragraph('', cls_doc)
                section.append(para)

            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
コード例 #26
0
ファイル: resources.py プロジェクト: james49/heat
    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
コード例 #27
0
def get_doc_object(obj, what=None, doc=None, config={}, builder=None):
    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'

    template_dirs = [os.path.join(os.path.dirname(__file__), 'templates')]
    if builder is not None:
        template_loader = BuiltinTemplateLoader()
        template_loader.init(builder, dirs=template_dirs)
    else:
        template_loader = FileSystemLoader(template_dirs)
    template_env = SandboxedEnvironment(loader=template_loader)
    config['template'] = template_env.get_template('numpydoc_docstring.rst')

    if what == 'class':
        return SphinxClassDoc(obj, func_doc=SphinxFunctionDoc, doc=doc,
                              config=config)
    elif what in ('function', 'method'):
        return SphinxFunctionDoc(obj, doc=doc, config=config)
    else:
        if doc is None:
            doc = pydoc.getdoc(obj)
        return SphinxObjDoc(obj, doc, config=config)
コード例 #28
0
ファイル: server.py プロジェクト: juleskt/ek128_work
    def docroutine(self, object, name, mod=None, funcs={}, classes={}, methods={}, cl=None):
        """Produce HTML documentation for a function or method object."""

        anchor = (cl and cl.__name__ or "") + "-" + name
        note = ""

        title = '<a name="%s"><strong>%s</strong></a>' % (self.escape(anchor), self.escape(name))

        if inspect.ismethod(object):
            args, varargs, varkw, defaults = inspect.getargspec(object)
            # exclude the argument bound to the instance, it will be
            # confusing to the non-Python user
            argspec = inspect.formatargspec(args[1:], varargs, varkw, defaults, formatvalue=self.formatvalue)
        elif inspect.isfunction(object):
            args, varargs, varkw, defaults = inspect.getargspec(object)
            argspec = inspect.formatargspec(args, varargs, varkw, defaults, formatvalue=self.formatvalue)
        else:
            argspec = "(...)"

        if isinstance(object, tuple):
            argspec = object[0] or argspec
            docstring = object[1] or ""
        else:
            docstring = pydoc.getdoc(object)

        decl = title + argspec + (note and self.grey('<font face="helvetica, arial">%s</font>' % note))

        doc = self.markup(docstring, self.preformat, funcs, classes, methods)
        doc = doc and "<dd><tt>%s</tt></dd>" % doc
        return "<dl><dt>%s</dt>%s</dl>\n" % (decl, doc)
コード例 #29
0
ファイル: resources.py プロジェクト: steveb/heat
    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
コード例 #30
0
def getsdoc(obj):
    "like pydoc's getdoc, but shorter docs"
    doc = getdoc(obj)
    doclines = doc.split('\n')
    # Skip over python specific comments.
    index = 0
    while index < len(doclines):
        if not _gPyModelineOrHashBangPat.match(doclines[index]):
            break
        index += 1
    #doclines = parseDocSummary(doclines, limit=12)
    if len(doclines) > (index + 1):
        if not doclines[index+1].strip():
            doclines.pop(index+1)
    doc = doclines[index] + '\n' + \
          ' '.join([x.strip() for x in doclines[index+1:index+11]])

    if not _gIsPy3:
        # Try encoding the docs, otherwise we'll run into problems when we want to
        # write out the tree data.
        try:
            doc = doc.decode("utf-8")
        except UnicodeDecodeError:
            try:
                doc = doc.decode(sys.getfilesystemencoding())
            except UnicodeDecodeError:
                doc = doc.decode("latin-1")

    return doc
コード例 #31
0
def find_autosummary_in_docstring(name: str, module: str = None, filename: str = None
                                  ) -> List[AutosummaryEntry]:
    """Find out what items are documented in the given object's docstring.

    See `find_autosummary_in_lines`.
    """
    if module:
        warnings.warn('module argument for find_autosummary_in_docstring() is deprecated.',
                      RemovedInSphinx50Warning)

    try:
        real_name, obj, parent, modname = import_by_name(name)
        lines = pydoc.getdoc(obj).splitlines()
        return find_autosummary_in_lines(lines, module=name, filename=filename)
    except AttributeError:
        pass
    except ImportError as e:
        print("Failed to import '%s': %s" % (name, e))
    except SystemExit:
        print("Failed to import '%s'; the module executes module level "
              "statement and it might call sys.exit()." % name)
    return []
コード例 #32
0
def get_doc_object(obj, what=None):
    if what is None:
        if inspect.isclass(obj):
            what = 'class'
        elif inspect.ismodule(obj):
            what = 'module'
        elif callable(obj):
            what = 'function'
        else:
            what = 'object'
    if what == 'class':
        doc = SphinxTraitsDoc(obj, '', func_doc=numpydoc.SphinxFunctionDoc)
        if looks_like_issubclass(obj, 'HasTraits'):
            for name, trait, comment in comment_eater.get_class_traits(obj):
                # Exclude private traits.
                if not name.startswith('_'):
                    doc['Traits'].append((name, trait, comment.splitlines()))
        return doc
    elif what in ('function', 'method'):
        return numpydoc.SphinxFunctionDoc(obj, '')
    else:
        return numpydoc.SphinxDocString(pydoc.getdoc(obj))
コード例 #33
0
ファイル: inspection.py プロジェクト: liaobs/bpython
def getpydocspec(f, func):
    try:
        argspec = pydoc.getdoc(f)
    except NameError:
        return None

    rx = re.compile(r'([a-zA-Z_][a-zA-Z0-9_]*?)\((.*?)\)')
    s = rx.search(argspec)
    if s is None:
        return None

    if not hasattr(f, '__name__') or s.groups()[0] != f.__name__:
        return None

    args = list()
    defaults = list()
    varargs = varkwargs = None
    kwonly_args = list()
    kwonly_defaults = dict()
    for arg in s.group(2).split(','):
        arg = arg.strip()
        if arg.startswith('**'):
            varkwargs = arg[2:]
        elif arg.startswith('*'):
            varargs = arg[1:]
        else:
            arg, _, default = arg.partition('=')
            if varargs is not None:
                kwonly_args.append(arg)
                if default:
                    kwonly_defaults[arg] = default
            else:
                args.append(arg)
                if default:
                    defaults.append(default)

    return [func, (args, varargs, varkwargs, defaults,
                   kwonly_args, kwonly_defaults)]
コード例 #34
0
 def docroutine(self,
                object,
                name,
                mod=None,
                funcs={},
                classes={},
                methods={},
                cl=None):
     anchor = (cl and cl.__name__ or '') + '-' + name
     note = ''
     title = '<a name="%s"><strong>%s</strong></a>' % (self.escape(anchor),
                                                       self.escape(name))
     if inspect.ismethod(object):
         args, varargs, varkw, defaults = inspect.getargspec(object.im_func)
         argspec = inspect.formatargspec(args[1:],
                                         varargs,
                                         varkw,
                                         defaults,
                                         formatvalue=self.formatvalue)
     elif inspect.isfunction(object):
         args, varargs, varkw, defaults = inspect.getargspec(object)
         argspec = inspect.formatargspec(args,
                                         varargs,
                                         varkw,
                                         defaults,
                                         formatvalue=self.formatvalue)
     else:
         argspec = '(...)'
     if isinstance(object, tuple):
         argspec = object[0] or argspec
         docstring = object[1] or ''
     else:
         docstring = pydoc.getdoc(object)
     decl = title + argspec + (note and self.grey(
         '<font face="helvetica, arial">%s</font>' % note))
     doc = self.markup(docstring, self.preformat, funcs, classes, methods)
     doc = doc and '<dd><tt>%s</tt></dd>' % doc
     return '<dl><dt>%s</dt>%s</dl>\n' % (decl, doc)
コード例 #35
0
    def doc_function(self, function, namespace, qname):
        """
        Document extension functions
        """
        from Ft.Xml.XPath.XPathTypes import g_xpathPrimitiveTypes

        attributes = {
            'namespace-uri': namespace or '',
            'name': qname,
        }
        self.start_element('function', attributes)

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

        result = getattr(function, 'result', None)
        result = g_xpathPrimitiveTypes.get(result, 'unknown')
        self.write_element('result', content=self.escape(result))

        argtypes = getattr(function, 'arguments', ())
        args, varargs, varkw, defaults = inspect.getargspec(function)
        firstdefault = len(args) - len(defaults or ())
        # All extension functions take 'context' as their first argument so
        # start the index at 1 instead of 0.
        # IMPLEMENTATION NOTE: using map(None, ...) instead of zip to not
        # truncate the list if argtypes is shorter than args.
        for i, argtype in map(None, xrange(1, len(args)), argtypes):
            argname = str(args[i])
            attributes = {
                'name': argname,
                'type': g_xpathPrimitiveTypes.get(argtype, argname),
            }
            if (i < firstdefault):
                attributes['required'] = 'yes'
            self.write_element('argument', attributes)

        self.end_element('function')
        return
コード例 #36
0
def get_doc_object(obj, what=None, doc=None, config={}, builder=None):

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

    if what == "class" and hasattr(obj, "run") and hasattr(obj, "audit"):
        what = "footing"
    template_dirs = [os.path.join(os.path.dirname(__file__), "templates")]
    if builder is not None:
        template_loader = BuiltinTemplateLoader()
        template_loader.init(builder, dirs=template_dirs)
    else:
        template_loader = FileSystemLoader(template_dirs)
    template_env = SandboxedEnvironment(loader=template_loader)
    config["template"] = template_env.get_template("footings_docstring.rst")
    if what == "footing":
        return SphinxFootingsDoc(obj,
                                 func_doc=SphinxFunctionDoc,
                                 doc=doc,
                                 config=config)
    elif what == "class":
        return SphinxClassDoc(obj,
                              func_doc=SphinxFunctionDoc,
                              doc=doc,
                              config=config)
    elif what in ("function", "method"):
        return SphinxFunctionDoc(obj, doc=doc, config=config)
    else:
        if doc is None:
            doc = pydoc.getdoc(obj)
        return SphinxObjDoc(obj, doc, config=config)
コード例 #37
0
def getpydocspec(f, func):
    try:
        argspec = pydoc.getdoc(f)
    except NameError:
        return None

    s = getpydocspec_re.search(argspec)
    if s is None:
        return None

    if not hasattr(f, "__name__") or s.groups()[0] != f.__name__:
        return None

    args = list()
    defaults = list()
    varargs = varkwargs = None
    kwonly_args = list()
    kwonly_defaults = dict()
    for arg in s.group(2).split(","):
        arg = arg.strip()
        if arg.startswith("**"):
            varkwargs = arg[2:]
        elif arg.startswith("*"):
            varargs = arg[1:]
        else:
            arg, _, default = arg.partition("=")
            if varargs is not None:
                kwonly_args.append(arg)
                if default:
                    kwonly_defaults[arg] = default
            else:
                args.append(arg)
                if default:
                    defaults.append(default)

    return ArgSpec(
        args, varargs, varkwargs, defaults, kwonly_args, kwonly_defaults, None
    )
コード例 #38
0
    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
コード例 #39
0
def get_doc(obj, parent):
    """
    Get the signature and docstring of the given object.

    Args:
        obj (routine): Function, method, methoddescriptor, or builtin.
        parent (class): Parent class or module of `obj`.

    Returns:
        tuple: (signature, docstring)

    """
    doc = pydoc.getdoc(obj).strip(WHITESPACE)
    path = get_path(parent, obj)
    try:
        sig = inspect.signature(obj)
        results = (sig, doc)
        logger.debug("Found signature for `%s` using inspect.", path)
    except ValueError:
        results = _sig_fallback(obj, parent, doc)
    if not doc:
        logger.debug("Could not find docstring for `%s`.", path)
    return results
コード例 #40
0
    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 not self['Methods']:
            self['Methods'] = [(name, '', '')
                               for name in sorted(self.methods)]
        if not self['Attributes']:
            self['Attributes'] = [(name, '', '')
                                  for name in sorted(self.properties)]
コード例 #41
0
def python_doc_help(request: Request, fun_name: str = None):
    if fun_name is None:
        return templates.TemplateResponse('show_text.html', {'request': request,
                                                             'text': '请在上方输入包名。', 'title': 'Python包文档'})
    try:
        m = import_module(fun_name)
        try:
            f = m.__file__
        except AttributeError:
            f = '无文件。'
    except (ImportError, ModuleNotFoundError):
        try:
            m = eval(fun_name)
        except Exception:
            m = False
            f = '查询出现错误。'
        else:
            f = '不是模块。'
    return templates.TemplateResponse('show_text.html',
                                      {'request': request, 'text': (f'原文件地址: {f}\n\n' + (pydoc.getdoc(m) if m
                                                                                         else '未找到此包或函数名。'))
                                       if not m or pydoc.getdoc(m) else f'原文件地址: {f}\n\n{fun_name}无文档',
                                       'title': fun_name + '的文档'})
コード例 #42
0
ファイル: helpers.py プロジェクト: bamanzi/site-lisp
def get_help(obj):
    """Returns the help of the given object.
    Inspired in the original pycomplete package
    """
    paren = obj.rfind("(")
    if paren != -1:
        obj = obj[:paren]
    if obj.endswith("(") or obj.endswith("."):
        obj = obj[:-1]
    found = False
    pobj = None
    context_dict = 'subprogram_globals'
    if not obj in context.get_context():
        context_dict = 'helper_globals'
        found = context.cimport(obj, context_dict)
    else:
        pobj = context.eval_code(obj)
    if obj not in context.subcontext_globals and found:
        pobj = context.eval_code(obj, context_dict)
    if not pobj:
        return "no help string for " + obj
    obj = context.eval_code(obj)
    return pydoc.getdoc(obj)
コード例 #43
0
    def system_methodHelp(self, method_name):
        """system.methodHelp('add') => "Adds two integers together"
        
        Returns a string containing documentation for the specified method."""
        method = None
        if method_name in self.funcs:
            method = self.funcs[method_name]
        elif self.instance is not None:
            if hasattr(self.instance, '_methodHelp'):
                return self.instance._methodHelp(method_name)
            if not hasattr(self.instance, '_dispatch'):
                try:
                    method = resolve_dotted_attribute(self.instance, method_name, self.allow_dotted_names)
                except AttributeError:
                    pass

        if method is None:
            return ''
        try:
            import pydoc
            return pydoc.getdoc(method)
        except ImportError:
            return method.__doc__
コード例 #44
0
ファイル: ioc.py プロジェクト: cristidomsa/Ally-Py
    def decorator(function):
        hasArg, hasType, type = processWithOneArg(function)

        if isinstance(setup, SetupConfig):
            # Updating the replaced configuration documentation.
            assert isinstance(setup, SetupConfig)
            documentation = getdoc(function)
            if documentation:
                if setup.__doc__: setup.__doc__ += '\n%s' % documentation
                else: setup.__doc__ = documentation

        if isinstance(setup, SetupEvent):
            if hasArg:
                raise SetupError(
                    'No argument expected for function %s, when replacing an event'
                    % function)
            if hasType:
                raise SetupError(
                    'No return type expected for function %s, when replacing an event'
                    % function)
            return update_wrapper(
                register(SetupEventReplace(function, setup), callerLocals()),
                function)

        if hasType:
            if not isclass(type):
                raise SetupError(
                    'Expected a class as the return annotation for function %s'
                    % function)
            else:
                types = (type, )
        else:
            types = ()

        return update_wrapper(
            register(SetupSourceReplace(function, setup, hasArg, types),
                     callerLocals()), function)
コード例 #45
0
ファイル: models.py プロジェクト: mripard/lava-server
    def methodHelp(self, method_name):
        """
        Name
        ----
        `methodHelp` (`method_name`)

        Description
        -----------
        Provide documentation for specified method.

        Arguments
        ---------
        `method_name`: string
            Name of the method whose documentation is required.

        Return value
        ------------
        Returns the documentation for specified method.
        """
        impl = self._context.mapper.lookup(method_name, self._context)
        if impl is None:
            return ""
        else:
            return pydoc.getdoc(impl)
コード例 #46
0
    def document(self, module):
        """
        Produce documentation for a given module object.
        """
        attributes = {'name': module.__name__}
        self.start_element('ext-module', attributes)

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

        namespaces = getattr(module, 'ExtNamespaces', {})
        functions = getattr(module, 'ExtFunctions', {})
        elements = getattr(module, 'ExtElements', {})

        if namespaces:
            self.start_element('namespaces')
            for namespace_uri, prefix in namespaces.items():
                self.doc_namespace(namespace_uri, prefix)
            self.end_element('namespaces')

        if functions:
            self.start_element('functions')
            for (namespace_uri, name), function in functions.items():
                qname = self.make_qname(namespaces, namespace_uri, name)
                self.doc_function(function, namespace_uri, qname)
            self.end_element('functions')

        if elements:
            self.start_element('elements')
            for (namespace_uri, name), element in elements.items():
                qname = self.make_qname(namespaces, namespace_uri, name)
                self.doc_element(element, namespace_uri, qname)
            self.end_element('elements')

        self.end_element('ext-module')
        return
コード例 #47
0
ファイル: traitsdoc.py プロジェクト: grlee77/mayavi
def get_doc_object(obj, what=None, doc=None, config=None):
    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' and obj is not None:
        doc = SphinxTraitsDoc(obj, '', func_doc=SphinxFunctionDoc, config=config)
        if looks_like_issubclass(obj, 'HasTraits'):
            for name, trait, comment in comment_eater.get_class_traits(obj):
                # Exclude private traits.
                if not name.startswith('_'):
                    doc['Traits'].append((name, trait, comment.splitlines()))
        return doc
    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)
コード例 #48
0
ファイル: docscrape.py プロジェクト: kyuhwas/formula
    def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc,
                 config={}):
        if not inspect.isclass(cls):
            raise ValueError("Initialise using a class. Got %r" % cls)
        self._cls = cls

        if modulename and not modulename.endswith('.'):
            modulename += '.'
        self._mod = modulename
        self._name = cls.__name__
        self._func_doc = func_doc

        if doc is None:
            doc = pydoc.getdoc(cls)

        NumpyDocString.__init__(self, doc)

        if config.get('show_class_members', True):
            if not self['Methods']:
                self['Methods'] = [(name, '', '')
                                   for name in sorted(self.methods)]
            if not self['Attributes']:
                self['Attributes'] = [(name, '', '')
                                      for name in sorted(self.properties)]
コード例 #49
0
ファイル: dispatcher.py プロジェクト: jmousset/trytond
def help_method(request, pool):
    obj, method = get_object_method(request, pool)
    return pydoc.getdoc(getattr(obj, method))
コード例 #50
0
ファイル: pydocmk.py プロジェクト: twardoch/pydocmk2
 def getdoc(self, object):
     doc = pydoc.getdoc(object)
     return '\n\n<pre class="doc" markdown="0">%s</pre>\n\n' % (doc)
コード例 #51
0
    def __init__(self, method, name=None, signature=None, docstring=None):

        self.method = method
        self.help = ''
        self.signature = []
        self.name = ''
        self.permission = None
        self.login_required = False
        self.args = []

        # set the method name based on @rpcmethod or the passed value
        # default to the actual method name
        if hasattr(method, 'external_name'):
            self.name = method.external_name
        elif name is not None:
            self.name = name
        else:
            try:
                # Python2
                self.name = method.func_name
            except AttributeError:
                # Python3
                self.name = method.__name__

        # get the help string for each method
        if docstring is not None:
            self.help = docstring
        else:
            self.help = pydoc.getdoc(method)

        # set the permissions based on the decorator
        self.permission = getattr(method, 'permission', None)

        # set the permissions based on the decorator
        self.login_required = getattr(method, 'login_required', self.permission
                                      is not None)

        # use inspection (reflection) to get the arguments
        # If we're using Python 3, look for function annotations, but allow
        # the signature parameter override them.

        try:
            args, varargs, keywords, defaults = inspect.getargspec(method)
            # varargs = None
            # varkw = None
            # kwonlyargs = None
            # kwonlydefaults = None
            annotations = {}

        except ValueError:
            full_args = inspect.getfullargspec(method)
            args = full_args.args
            # varargs = full_args.varargs
            # varkw = full_args.varkw
            # defaults = full_args.defaults
            # kwonlyargs = full_args.kwonlyargs
            # kwonlydefaults = full_args.kwonlydefaults
            annotations = full_args.annotations

        self.args = [arg for arg in args if arg not in ('self', 'request')]

        self.signature.append(annotations.get('return', 'object'))
        for i, arg in enumerate(self.args):
            annotation = annotations.get(arg, None)
            if annotation:
                self.signature.append(annotation)
            else:
                try:
                    self.signature.append(method.signature[i])
                except (IndexError, AttributeError):
                    self.signature.append('object')

        if hasattr(method, 'signature') and \
           len(method.signature) == len(self.args) + 1:
            # use the @rpcmethod signature if it has the correct
            # number of args
            self.signature = method.signature
        elif signature is not None and len(self.args) + 1 == len(signature):
            # use the passed signature if it has the correct number
            # of arguments
            self.signature = signature
コード例 #52
0
def _find_return_type(func):
    for line in pydoc.getdoc(func).splitlines():
        if line.startswith(PYDOC_RETURN_LABEL):
            return line[len(PYDOC_RETURN_LABEL):].strip()
    return ""
コード例 #53
0
 def get_watch_argument_name(self, func):
     if PYDOC_FOLLOW_PARAM in pydoc.getdoc(func):
         return 'follow'
     else:
         return 'watch'
コード例 #54
0
ファイル: test_api.py プロジェクト: zer0kg/pandas
 def test_class_axis(self):
     # https://github.com/pandas-dev/pandas/issues/18147
     # no exception and no empty docstring
     assert pydoc.getdoc(Series.index)
コード例 #55
0
 def test_class_axis(self):
     # GH 18147
     # no exception and no empty docstring
     assert pydoc.getdoc(DataFrame.index)
     assert pydoc.getdoc(DataFrame.columns)
コード例 #56
0
ファイル: repl.py プロジェクト: DexterLB/unifordummies
    def complete(self, tab=False):
        """Construct a full list of possible completions and construct and
        display them in a window. Also check if there's an available argspec
        (via the inspect module) and bang that on top of the completions too.
        The return value is whether the list_win is visible or not."""

        self.docstring = None
        if not self.get_args():
            self.argspec = None
        elif self.current_func is not None:
            try:
                self.docstring = pydoc.getdoc(self.current_func)
            except IndexError:
                self.docstring = None
            else:
                # pydoc.getdoc() returns an empty string if no
                # docstring was found
                if not self.docstring:
                    self.docstring = None

        cw = self.cw()
        cs = self.current_string()
        if not cw:
            self.matches = []
            self.matches_iter.update()
        if not (cw or cs):
            return bool(self.argspec)

        if cs and tab:
            # Filename completion
            self.matches = list()
            username = cs.split(os.path.sep, 1)[0]
            user_dir = os.path.expanduser(username)
            for filename in glob(os.path.expanduser(cs + '*')):
                if os.path.isdir(filename):
                    filename += os.path.sep
                if cs.startswith('~'):
                    filename = username + filename[len(user_dir):]
                self.matches.append(filename)
            self.matches_iter.update(cs, self.matches)
            return bool(self.matches)
        elif cs:
            # Do not provide suggestions inside strings, as one cannot tab
            # them so they would be really confusing.
            self.matches_iter.update()
            return False

        # Check for import completion
        e = False
        matches = importcompletion.complete(self.current_line(), cw)
        if matches is not None and not matches:
            self.matches = []
            self.matches_iter.update()
            return False

        if matches is None:
            # Nope, no import, continue with normal completion
            try:
                self.completer.complete(cw, 0)
            except Exception:
                # This sucks, but it's either that or list all the exceptions that could
                # possibly be raised here, so if anyone wants to do that, feel free to send me
                # a patch. XXX: Make sure you raise here if you're debugging the completion
                # stuff !
                e = True
            else:
                matches = self.completer.matches
                if (self.config.complete_magic_methods and self.buffer
                        and self.buffer[0].startswith("class ")
                        and self.current_line().lstrip().startswith("def ")):
                    matches.extend(name for name in self.config.magic_methods
                                   if name.startswith(cw))

        if not e and self.argspec:
            matches.extend(name + '=' for name in self.argspec[1][0]
                           if isinstance(name, str) and name.startswith(cw))
            if py3:
                matches.extend(name + '=' for name in self.argspec[1][4]
                               if name.startswith(cw))

        # unless the first character is a _ filter out all attributes starting with a _
        if not e and not cw.split('.')[-1].startswith('_'):
            matches = [
                match for match in matches
                if not match.split('.')[-1].startswith('_')
            ]

        if e or not matches:
            self.matches = []
            self.matches_iter.update()
            if not self.argspec:
                return False
        else:
            # remove duplicates
            self.matches = sorted(set(matches))

        if len(self.matches) == 1 and not self.config.auto_display_list:
            self.list_win_visible = True
            self.tab()
            return False

        self.matches_iter.update(cw, self.matches)
        return True
コード例 #57
0
ファイル: macros.py プロジェクト: pombredanne/trachacks
 def get_macro_description(self, name):
     import pydoc
     return pydoc.getdoc(getattr(self, 'render_' + name.lower()))
コード例 #58
0
ファイル: build.py プロジェクト: demntor/pymodbus
    def docmodule(self,
                  object,
                  name=None,
                  mod=None,
                  packageContext=None,
                  *ignored):
        """Produce HTML documentation for a module object."""
        name = object.__name__  # ignore the passed-in name
        parts = split(name, '.')
        links = []
        for i in range(len(parts) - 1):
            links.append(
                '<a href="%s.html"><font color="#ffffff">%s</font></a>' %
                (join(parts[:i + 1], '.'), parts[i]))
        linkedname = join(links + parts[-1:], '.')
        head = '<big><big><strong>%s</strong></big></big>' % linkedname
        try:
            path = inspect.getabsfile(object)
            url = path
            if sys.platform == 'win32':
                import nturl2path
                url = nturl2path.pathname2url(path)
            filelink = '<a href="file:%s">%s</a>' % (url, path)
        except TypeError:
            filelink = '(built-in)'
        info = []
        if hasattr(object, '__version__'):
            version = str(object.__version__)
            if version[:11] == '$' + 'Revision: ' and version[-1:] == '$':
                version = strip(version[11:-1])
            info.append('version %s' % self.escape(version))
        if hasattr(object, '__date__'):
            info.append(self.escape(str(object.__date__)))
        if info:
            head = head + ' (%s)' % join(info, ', ')
        result = self.heading(head, '#ffffff', '#7799ee',
                              '<a href=".">index</a><br>' + filelink)

        modules = inspect.getmembers(object, inspect.ismodule)

        classes, cdict = [], {}
        for key, value in inspect.getmembers(object, inspect.isclass):
            if (inspect.getmodule(value) or object) is object:
                classes.append((key, value))
                cdict[key] = cdict[value] = '#' + key
        for key, value in classes:
            for base in value.__bases__:
                key, modname = base.__name__, base.__module__
                module = sys.modules.get(modname)
                if modname != name and module and hasattr(module, key):
                    if getattr(module, key) is base:
                        if not cdict.has_key(key):
                            cdict[key] = cdict[base] = modname + '.html#' + key
        funcs, fdict = [], {}
        for key, value in inspect.getmembers(object, inspect.isroutine):
            if inspect.isbuiltin(value) or inspect.getmodule(value) is object:
                funcs.append((key, value))
                fdict[key] = '#-' + key
                if inspect.isfunction(value): fdict[value] = fdict[key]
        data = []
        for key, value in inspect.getmembers(object, pydoc.isdata):
            if key not in ['__builtins__', '__doc__']:
                data.append((key, value))

        doc = self.markup(pydoc.getdoc(object), self.preformat, fdict, cdict)
        doc = doc and '<tt>%s</tt>' % doc
        result = result + '<p>%s</p>\n' % doc

        packageContext.clean(classes, object)
        packageContext.clean(funcs, object)
        packageContext.clean(data, object)

        if hasattr(object, '__path__'):
            modpkgs = []
            modnames = []
            for file in os.listdir(object.__path__[0]):
                path = os.path.join(object.__path__[0], file)
                modname = inspect.getmodulename(file)
                if modname and modname not in modnames:
                    modpkgs.append((modname, name, 0, 0))
                    modnames.append(modname)
                elif pydoc.ispackage(path):
                    modpkgs.append((file, name, 1, 0))
            modpkgs.sort()
            contents = self.multicolumn(modpkgs, self.modpkglink)
            ##			result = result + self.bigsection(
            ##				'Package Contents', '#ffffff', '#aa55cc', contents)
            result = result + self.moduleSection(object, packageContext)
        elif modules:
            contents = self.multicolumn(
                modules, lambda (key, value), s=self: s.modulelink(value))
            result = result + self.bigsection('Modules', '#fffff', '#aa55cc',
                                              contents)

        if classes:
            classlist = map(lambda (key, value): value, classes)
            contents = [
                self.formattree(inspect.getclasstree(classlist, 1), name)
            ]
            for key, value in classes:
                contents.append(self.document(value, key, name, fdict, cdict))
            result = result + self.bigsection('Classes', '#ffffff', '#ee77aa',
                                              join(contents))
        if funcs:
            contents = []
            for key, value in funcs:
                contents.append(self.document(value, key, name, fdict, cdict))
            result = result + self.bigsection('Functions', '#ffffff',
                                              '#eeaa77', join(contents))
        if data:
            contents = []
            for key, value in data:
                try:
                    contents.append(self.document(value, key))
                except Exception, err:
                    pass
            result = result + self.bigsection('Data', '#ffffff', '#55aa55',
                                              join(contents, '<br>\n'))
コード例 #59
0
ファイル: scipyoptdoc.py プロジェクト: jamesBaker361/pynary
        def run(self):
            env = self.state.document.settings.env

            # Interface function
            name = self.arguments[0].strip()
            obj = _import_object(name)
            args, varargs, keywords, defaults = inspect.getargspec(obj)

            # Implementation function
            impl_name = self.options['impl']
            impl_obj = _import_object(impl_name)
            impl_args, impl_varargs, impl_keywords, impl_defaults = inspect.getargspec(
                impl_obj)

            # Format signature taking implementation into account
            args = list(args)
            defaults = list(defaults)

            def set_default(arg, value):
                j = args.index(arg)
                defaults[len(defaults) - (len(args) - j)] = value

            def remove_arg(arg):
                if arg not in args:
                    return
                j = args.index(arg)
                if j < len(args) - len(defaults):
                    del args[j]
                else:
                    del defaults[len(defaults) - (len(args) - j)]
                    del args[j]

            options = []
            for j, opt_name in enumerate(impl_args):
                if opt_name in args:
                    continue
                if j >= len(impl_args) - len(impl_defaults):
                    options.append(
                        (opt_name, impl_defaults[len(impl_defaults) -
                                                 (len(impl_args) - j)]))
                else:
                    options.append((opt_name, None))
            set_default('options', dict(options))
            set_default('method', self.options['method'].strip())

            for arg in list(args):
                if arg not in impl_args and arg not in ('fun', 'x0', 'args',
                                                        'tol', 'callback',
                                                        'method', 'options'):
                    remove_arg(arg)

            signature = inspect.formatargspec(args, varargs, keywords,
                                              defaults)

            # Produce output
            self.options['noindex'] = True
            self.arguments[0] = name + signature
            lines = textwrap.dedent(pydoc.getdoc(impl_obj)).splitlines()
            new_lines = []
            for line in lines:
                if line.strip() == 'Options':
                    new_lines.append("Other Parameters")
                elif line.strip() == "-" * len('Options'):
                    new_lines.append("-" * len("Other Parameters"))
                else:
                    new_lines.append(line)
            mangle_docstrings(env.app, 'function', name, None, None, new_lines)
            lines = new_lines
            new_lines = []
            for line in lines:
                if line.strip() == ':Other Parameters:':
                    new_lines.extend((BLURB % (name, )).splitlines())
                    new_lines.append(':Options:')
                else:
                    new_lines.append(line)
            self.content = ViewList(new_lines, self.content.parent)
            return base_directive.run(self)
コード例 #60
0
    def test_member_deprecation(self):
        from deprecation_example import ExampleClass

        def base_deprecation():
            warnings.warn("Non-drake warning",
                          category=DeprecationWarning,
                          stacklevel=2)

        # At this point, no other deprecations should have been thrown, so we
        # will test with the default `once` filter.
        with warnings.catch_warnings(record=True) as w:
            base_deprecation()  # Should not appear.
            obj = ExampleClass()
            # Call each deprecated method / propery repeatedly; it should only
            # warn once per unique line of source code.
            # - Method.
            for _ in range(3):
                method = ExampleClass.deprecated_method
                self.assertEqual(obj.deprecated_method(), 1)
                # The next line will not show a warning.
                self.assertEqual(method(obj), 1)
            self.assertEqual(method.__doc__, ExampleClass.doc_method)
            # - Property.
            for _ in range(3):
                prop = ExampleClass.deprecated_prop
                self.assertEqual(obj.deprecated_prop, 2)
                # The next line will not show a warning.
                self.assertEqual(prop.__get__(obj), 2)
            self.assertEqual(prop.__doc__, ExampleClass.doc_prop)
            # Check warnings.
            self.assertEqual(len(w), 2)
            self._check_warning(w[0], ExampleClass.message_method)
            self._check_warning(w[1], ExampleClass.message_prop)

        # Because `once` uses a (somehow opaque) registry (not accessible via
        # `warnings.once*registry` or `_warnings.once_registry`), we must
        # change the filter to test behavior. `reload`ing `warnings` and/or
        # `_warnings` also does not work.
        # See caveat here with `catch_warnings`:
        # https://docs.python.org/2/library/warnings.html#testing-warnings

        # Enable deprecation warnings as well.
        with warnings.catch_warnings(record=True) as w:
            # N.B. This also overrides `DrakeDeprecationWarning` settings
            # because of ordering. We can redefine a filter for
            # `DrakeDeprecationWarning` if so desired.
            warnings.simplefilter("default", DeprecationWarning)
            base_deprecation()
            method = ExampleClass.deprecated_method
            self.assertEqual(len(w), 2)
            self._check_warning(w[0],
                                "Non-drake warning",
                                type=DeprecationWarning)
            self._check_warning(w[1], ExampleClass.message_method)

        # Edit the following flags to manually inspect the warnings generated.
        show_warnings = False
        if show_warnings:
            include_base_deprecations = False
            if include_base_deprecations:
                warnings.simplefilter("default", DeprecationWarning)
            else:
                # See above notes for why we have to set this.
                warnings.simplefilter("default", DrakeDeprecationWarning)
            for _ in range(3):
                base_deprecation()
                method = ExampleClass.deprecated_method
                method_extra = ExampleClass.deprecated_method
                prop = ExampleClass.deprecated_prop
                prop_extra = ExampleClass.deprecated_prop
            # N.B. `help(<module>)` is super verbose.
            print("Help text:\n{}".format(
                pydoc.getdoc(pydrake.util.deprecation)))
            # Manually set this back to `once`.
            warnings.simplefilter("ignored", DeprecationWarning)
            warnings.simplefilter("once", DrakeDeprecationWarning)