def get_motor_attr(motor_class, name, *defargs):
    """If any Motor attributes can't be accessed, grab the equivalent PyMongo
    attribute. While we're at it, store some info about each attribute
    in the global motor_info dict.
    """
    attr = safe_getattr(motor_class, name)
    method_class = safe_getattr(attr, 'im_class', None)
    from_pymongo = not safe_getattr(
        method_class, '__module__', '').startswith('motor')

    # Store some info for process_motor_nodes()
    full_name = '%s.%s.%s' % (
        motor_class.__module__, motor_class.__name__, name)

    is_async_method = getattr(attr, 'is_async_method', False)
    is_cursor_method = getattr(attr, 'is_motorcursor_chaining_method', False)
    if is_async_method or is_cursor_method:
        pymongo_method = getattr(
            motor_class.__delegate_class__, attr.pymongo_method_name)
    else:
        pymongo_method = None

    is_pymongo_docstring = from_pymongo or is_async_method or is_cursor_method

    motor_info[full_name] = {
        # These sub-attributes are set in motor.asynchronize()
        'is_async_method': is_async_method,
        'callback_required': getattr(attr, 'callback_required', False),
        'is_pymongo_docstring': is_pymongo_docstring,
        'pymongo_method': pymongo_method }

    return attr

    def get_members(clazz, obj, typ):
        names = set()
        items = []

        # the default dir
        for name in dir(obj):
            try:
                documenter = get_documenter(safe_getattr(obj, name), obj)
            except AttributeError:
                continue
            if documenter.objtype == typ and not name.startswith('_'):
                if name not in AutoCosmoSummary.exclude:
                    items.append((clazz,name))
                    names.add(name) # keep track of method/attribute conflicts

        # the delegate dro
        for n in obj.dro:
            for name in dir(n):
                try:
                    documenter = get_documenter(safe_getattr(n, name), n)
                except AttributeError:
                    continue

                # dont do conflicts
                if name not in names:
                    if documenter.objtype == typ and not name.startswith('_'):
                        if name not in AutoCosmoSummary.exclude:
                            x = "%s.%s" %(n.__module__, n.__name__)
                            items.append((x,name))
                            names.add(name)

        return ['~%s.%s' %item for item in sorted(items, key=lambda x: x[1])]

 def get_object_members(self, want_all):
     if want_all:
         # if not hasattr(self.object, '__all__'):
         #     for implicit module members, check __module__ to avoid
         #     documenting imported objects
             return True, safe_getmembers(self.object)
         # else:
         #     memberlist = self.object.__all__
         #     # Sometimes __all__ is broken...
         #     if not isinstance(memberlist, (list, tuple)) or not \
         #        all(isinstance(entry, string_types) for entry in memberlist):
         #         self.directive.warn(
         #             '__all__ should be a list of strings, not %r '
         #             '(in module %s) -- ignoring __all__' %
         #             (memberlist, self.fullname))
         #         # fall back to all members
         #         return True, safe_getmembers(self.object)
     else:
         memberlist = self.options.members or []
     ret = []
     for mname in memberlist:
         try:
             ret.append((mname, safe_getattr(self.object, mname)))
         except AttributeError:
             self.directive.warn(
                 'missing attribute mentioned in :members: or __all__: '
                 'module %s, attribute %s' % (
                     safe_getattr(self.object, '__name__', '???'), mname))
     return False, ret

def get_motor_attr(motor_class, name, *defargs):
    """If any Motor attributes can't be accessed, grab the equivalent PyMongo
    attribute. While we're at it, store some info about each attribute
    in the global motor_info dict.
    """
    attr = safe_getattr(motor_class, name)
    method_class = safe_getattr(attr, "im_class", None)
    from_pymongo = not safe_getattr(method_class, "__module__", "").startswith("motor")

    # Store some info for process_motor_nodes()
    full_name = "%s.%s.%s" % (motor_class.__module__, motor_class.__name__, name)

    is_async_method = getattr(attr, "is_async_method", False)
    is_cursor_method = getattr(attr, "is_motorcursor_chaining_method", False)
    if is_async_method or is_cursor_method:
        pymongo_method = getattr(motor_class.__delegate_class__, attr.pymongo_method_name)
    else:
        pymongo_method = None

    is_pymongo_docstring = from_pymongo or is_async_method or is_cursor_method

    motor_info[full_name] = {
        # These sub-attributes are set in motor.asynchronize()
        "is_async_method": is_async_method,
        "is_pymongo_docstring": is_pymongo_docstring,
        "pymongo_method": pymongo_method,
    }

    return attr

def test_safe_getattr_with_exception():
    class Foo:
        def __getattr__(self, item):
            raise Exception

    obj = Foo()

    try:
        inspect.safe_getattr(obj, 'bar')
    except AttributeError as exc:
        assert exc.args[0] == 'bar'
    else:
        pytest.fail('AttributeError not raised')

    def test_safe_getattr_with_exception(self):
        class Foo(object):
            def __getattr__(self, item):
                raise Exception

        obj = Foo()

        try:
            inspect.safe_getattr(obj, 'bar')
        except AttributeError as exc:
            self.assertEqual(exc.args[0], 'bar')
        else:
            self.fail('AttributeError not raised')

    def test_safe_getattr_with___dict___override(self):
        class Foo(object):
            @property
            def __dict__(self):
                raise Exception

        obj = Foo()

        try:
            inspect.safe_getattr(obj, 'bar')
        except AttributeError as exc:
            self.assertEqual(exc.args[0], 'bar')
        else:
            self.fail('AttributeError not raised')

def test_safe_getattr_with___dict___override():
    class Foo:
        @property
        def __dict__(self):
            raise Exception

    obj = Foo()

    try:
        inspect.safe_getattr(obj, 'bar')
    except AttributeError as exc:
        assert exc.args[0] == 'bar'
    else:
        pytest.fail('AttributeError not raised')

def test_safe_getattr_with_property_exception():
    class Foo(object):
        @property
        def bar(self):
            raise Exception

    obj = Foo()

    try:
        inspect.safe_getattr(obj, 'bar')
    except AttributeError as exc:
        assert exc.args[0] == 'bar'
    else:
        pytest.fail('AttributeError not raised')

            def get_members_class(obj, typ, include_public=[],
                                  include_base=False):
                """
                typ = None -> all
                include_base -> include attrs that are from a base class
                """
                items = []

                # using dir gets all of the attributes, including the elements
                # from the base class, otherwise use __slots__ or __dict__
                if include_base:
                    names = dir(obj)
                else:
                    if hasattr(obj, '__slots__'):
                        names = tuple(getattr(obj, '__slots__'))
                    else:
                        names = getattr(obj, '__dict__').keys()

                for name in names:
                    try:
                        documenter = get_documenter(safe_getattr(obj, name),
                                                    obj)
                    except AttributeError:
                        continue
                    if typ is None or documenter.objtype == typ:
                        items.append(name)
                public = [x for x in items
                          if x in include_public or not x.startswith('_')]
                return public, items

def get_motor_attr(motor_class, name, *defargs):
    """If any Motor attributes can't be accessed, grab the equivalent PyMongo
    attribute. While we're at it, store some info about each attribute
    in the global motor_info dict.
    """
    from_pymongo = False
    try:
        attr = safe_getattr(motor_class, name, *defargs)
    except AttributeError:
        # Typically, this means 'name' is refers not to an async method like
        # MotorDatabase.command, but to a ReadOnlyProperty, e.g.
        # MotorClient.close(). The latter can't be accessed directly, but we
        # can get the docstring and method signature from the equivalent
        # PyMongo attribute, e.g. pymongo.mongo_client.MongoClient.close().
        attr = getattr(motor_class.__delegate_class__, name, *defargs)
        from_pymongo = True

    # Store some info for process_motor_nodes()
    full_name = '%s.%s.%s' % (
        motor_class.__module__, motor_class.__name__, name)

    is_async_method = getattr(attr, 'is_async_method', False)
    motor_info[full_name] = {
        # These sub-attributes are set in motor.asynchronize()
        'is_async_method': is_async_method,
        'callback_required': getattr(attr, 'callback_required', False),
        'is_pymongo_docstring': from_pymongo or is_async_method}

    return attr

def get_motor_attr(motor_class, name, *defargs):
    """If any Motor attributes can't be accessed, grab the equivalent PyMongo
    attribute. While we're at it, store some info about each attribute
    in the global motor_info dict.
    """
    attr = safe_getattr(motor_class, name)

    # Store some info for process_motor_nodes()
    full_name = '%s.%s.%s' % (
        motor_class.__module__, motor_class.__name__, name)

    full_name_legacy = 'motor.%s.%s.%s' % (
        motor_class.__module__, motor_class.__name__, name)

    # These sub-attributes are set in motor.asynchronize()
    has_coroutine_annotation = getattr(attr, 'coroutine_annotation', False)
    is_async_method = getattr(attr, 'is_async_method', False)
    is_cursor_method = getattr(attr, 'is_motorcursor_chaining_method', False)
    if is_async_method or is_cursor_method:
        pymongo_method = getattr(
            motor_class.__delegate_class__, attr.pymongo_method_name)
    else:
        pymongo_method = None

    # attr.doc is set by statement like 'error = AsyncRead(doc="OBSOLETE")'.
    is_pymongo_doc = pymongo_method and attr.__doc__ == pymongo_method.__doc__

    motor_info[full_name] = motor_info[full_name_legacy] = {
        'is_async_method': is_async_method or has_coroutine_annotation,
        'is_pymongo_docstring': is_pymongo_doc,
        'pymongo_method': pymongo_method,
    }

    return attr

 def add_content(self, more_content, no_docstring=False):
     if self.doc_as_attr:
         classname = safe_getattr(self.object, '__name__', None)
         if classname:
             content = ViewList(
                 [_('alias of :class:`%s`') % classname], source='')
             MatModuleLevelDocumenter.add_content(self, content,
                                               no_docstring=True)
     else:
         MatModuleLevelDocumenter.add_content(self, more_content)

 def def_members(obj, typ, include_public=[]):
     items = []
     try:
         obj_dict = safe_getattr(obj, '__dict__')
     except AttributeError:
         return []
     defined = obj_dict.keys()
     defined.sort()
     for name in defined:
         if sys.skip_member(name, obj): continue
         try:
             documenter = get_documenter(safe_getattr(obj, name), obj)
         except AttributeError:
             continue
         if documenter.objtype == typ:
             items.append(name)
     public = [x for x in items
               if x in include_public or not x.startswith('_')]
     return public

def test_safe_getattr_with_default():
    class Foo:
        def __getattr__(self, item):
            raise Exception

    obj = Foo()

    result = inspect.safe_getattr(obj, 'bar', 'baz')

    assert result == 'baz'

 def get_object_members(self, want_all):
     if want_all:
         if not hasattr(self.object, '__all__'):
             # for implicit module members, check __module__ to avoid
             # documenting imported objects
             return True, safe_getmembers(self.object)
         else:
             memberlist = self.object.__all__
     else:
         memberlist = self.options.members or []
     ret = []
     for mname in memberlist:
         try:
             ret.append((mname, safe_getattr(self.object, mname)))
         except AttributeError:
             self.directive.warn(
                 'missing attribute mentioned in :members: or __all__: '
                 'module %s, attribute %s' % (
                 safe_getattr(self.object, '__name__', '???'), mname))
     return False, ret

 def get_members(obj, typ, include_public=[]):
     items = []
     for name in dir(obj):
         try:
             documenter = get_documenter(safe_getattr(obj, name), obj)
         except AttributeError:
             continue
         if documenter.objtype == typ:
             items.append(name)
     public = [x for x in items if x in include_public or not x.startswith("_")]
     return public, items

def get_motor_attr(motor_class, name, *defargs):
    """If any Motor attributes can't be accessed, grab the equivalent PyMongo
    attribute. While we're at it, store some info about each attribute
    in the global motor_info dict.
    """
    attr = safe_getattr(motor_class, name)
    method_class = safe_getattr(attr, 'im_class', None)
    from_pymongo = not safe_getattr(
        method_class, '__module__', '').startswith('motor')

    # Store some info for process_motor_nodes()
    full_name = '%s.%s.%s' % (
        motor_class.__module__, motor_class.__name__, name)

    # TODO: hack! All docstrings should be updated with fully-qualified refs.
    full_name_legacy = 'motor.motor_tornado.%s.%s' % (
        motor_class.__name__, name)

    has_coroutine_annotation = getattr(attr, 'coroutine_annotation', False)
    is_async_method = getattr(attr, 'is_async_method', False)
    is_cursor_method = getattr(attr, 'is_motorcursor_chaining_method', False)
    if is_async_method or is_cursor_method:
        pymongo_method = getattr(
            motor_class.__delegate_class__, attr.pymongo_method_name)
    else:
        pymongo_method = None

    # attr.doc is set by statement like 'error = AsyncRead(doc="OBSOLETE")'.
    is_pymongo_doc = ((from_pymongo or is_async_method or is_cursor_method)
                      and not getattr(attr, 'doc', None))

    motor_info[full_name] = motor_info[full_name_legacy] = {
        'has_coroutine_annotation': has_coroutine_annotation,
        # These sub-attributes are set in motor.asynchronize()
        'is_async_method': is_async_method,
        'is_pymongo_docstring': is_pymongo_doc,
        'pymongo_method': pymongo_method,
    }

    return attr

 def get_members(app, obj, typ, include_public=None):
     if not include_public:
         include_public = []
     items = []
     for name in vars(obj):
         try:
             documenter = get_documenter(app, safe_getattr(obj, name), obj)
         except AttributeError:
             continue
         if documenter.objtype == typ:
             items.append(name)
     items.sort()
     public = [x for x in items if x in include_public or not x.startswith('_')]
     return public, items

 def get_members(obj, typ, include_public=[]):
     # type: (Any, unicode, List[unicode]) -> Tuple[List[unicode], List[unicode]]
     items = []  # type: List[unicode]
     for name in dir(obj):
         try:
             documenter = get_documenter(safe_getattr(obj, name),
                                         obj)
         except AttributeError:
             continue
         if documenter.objtype == typ:
             items.append(name)
     public = [x for x in items
               if x in include_public or not x.startswith('_')]
     return public, items