code: def igetattr(self, name, context=None):
          
  
          if name in self.special_attributes:
              yield self.special_attributes.lookup(name)
              return
  
          try:
              mro = self.super_mro()
          # Don't let invalid MROs or invalid super calls
          # leak out as is from this function.
          except exceptions.SuperError as exc:
              raise exceptions.AttributeInferenceError(
                  (
                      "Lookup for {name} on {target!r} because super call {super!r} "
                      "is invalid."
                  ),
                  target=self,
                  attribute=name,
                  context=context,
                  super_=exc.super_,
              ) from exc
          except exceptions.MroError as exc:
              raise exceptions.AttributeInferenceError(
                  (
                      "Lookup for {name} on {target!r} failed because {cls!r} has an "
                      "invalid MRO."
                  ),
                  target=self,
                  attribute=name,
                  context=context,
                  mros=exc.mros,
                  cls=exc.cls,
              ) from exc
          found = False
          for cls in mro:
              if name not in cls.locals:
                  continue
  
              found = True
              for inferred in bases._infer_stmts([cls[name]], context, frame=self):
                  if not isinstance(inferred, scoped_nodes.FunctionDef):
                      yield inferred
                      continue
  
                  # We can obtain different descriptors from a super depending
                  # on what we are accessing and where the super call is.
                  if inferred.type == "classmethod":
                      yield bases.BoundMethod(inferred, cls)
                  elif self._scope.type == "classmethod" and inferred.type == "method":
                      yield inferred
                  elif self._class_based or inferred.type == "staticmethod":
                      yield inferred
                  elif bases._is_property(inferred):
                      # TODO: support other descriptors as well.
                      try:
                          yield from inferred.infer_call_result(self, context)
                      except exceptions.InferenceError:
                          yield util.Uninferable
                  else:
                      yield bases.BoundMethod(inferred, cls)
  
          if not found:
              raise exceptions.AttributeInferenceError(
                  target=self, attribute=name, context=context
              )
docs: Retrieve the inferred values of the given attribute name.