text: class BoundRelatedObject(object):
      def __init__(self, related_object, field_mapping, original):
          self.relation = related_object
          self.field_mappings = field_mapping[related_object.name]
  
      def template_name(self):
          raise NotImplementedError
  
      def __repr__(self):
          return repr(self.__dict__)
  
  class RelatedObject(object):
      def __init__(self, parent_model, model, field):
          self.parent_model = parent_model
          self.model = model
          self.opts = model._meta
          self.field = field
          self.edit_inline = field.rel.edit_inline
          self.name = '%s:%s' % (self.opts.app_label, self.opts.module_name)
          self.var_name = self.opts.object_name.lower()
  
      def flatten_data(self, follow, obj=None):
          new_data = {}
          rel_instances = self.get_list(obj)
          for i, rel_instance in enumerate(rel_instances):
              instance_data = {}
              for f in self.opts.fields + self.opts.many_to_many:
                  # TODO: Fix for recursive manipulators.
                  fol = follow.get(f.name, None)
                  if fol:
                      field_data = f.flatten_data(fol, rel_instance)
                      for name, value in field_data.items():
                          instance_data['%s.%d.%s' % (self.var_name, i, name)] = value
              new_data.update(instance_data)
          return new_data
  
      def extract_data(self, data):
          """
          Pull out the data meant for inline objects of this class,
          i.e. anything starting with our module name.
          """
          return data # TODO
  
      def get_list(self, parent_instance=None):
          "Get the list of this type of object from an instance of the parent class."
          if parent_instance is not None:
              attr = getattr(parent_instance, self.get_accessor_name())
              if self.field.rel.multiple:
                  # For many-to-many relationships, return a list of objects
                  # corresponding to the xxx_num_in_admin options of the field
                  objects = list(attr.all())
  
                  count = len(objects) + self.field.rel.num_extra_on_change
                  if self.field.rel.min_num_in_admin:
                      count = max(count, self.field.rel.min_num_in_admin)
                  if self.field.rel.max_num_in_admin:
                      count = min(count, self.field.rel.max_num_in_admin)
  
                  change = count - len(objects)
                  if change > 0:
                      return objects + [None] * change
                  if change < 0:
                      return objects[:change]
                  else: # Just right
                      return objects
              else:
                  # A one-to-one relationship, so just return the single related
                  # object
                  return [attr]
          else:
              if self.field.rel.min_num_in_admin:
                  return [None] * max(self.field.rel.num_in_admin, self.field.rel.min_num_in_admin)
              else:
                  return [None] * self.field.rel.num_in_admin
  
      def get_db_prep_lookup(self, lookup_type, value):
          # Defer to the actual field definition for db prep
          return self.field.get_db_prep_lookup(lookup_type, value)
          
      def editable_fields(self):
          "Get the fields in this class that should be edited inline."
          return [f for f in self.opts.fields + self.opts.many_to_many if f.editable and f != self.field]
  
      def get_follow(self, override=None):
          if isinstance(override, bool):
              if override:
                  over = {}
              else:
                  return None
          else:
              if override:
                  over = override.copy()
              elif self.edit_inline:
                  over = {}
              else:
                  return None
  
          over[self.field.name] = False
          return self.opts.get_follow(over)
  
      def get_manipulator_fields(self, opts, manipulator, change, follow):
          if self.field.rel.multiple:
              if change:
                  attr = getattr(manipulator.original_object, self.get_accessor_name())
                  count = attr.count()
                  count += self.field.rel.num_extra_on_change
              else:
                  count = self.field.rel.num_in_admin
              if self.field.rel.min_num_in_admin:
                  count = max(count, self.field.rel.min_num_in_admin)
              if self.field.rel.max_num_in_admin:
                  count = min(count, self.field.rel.max_num_in_admin)
          else:
              count = 1
  
          fields = []
          for i in range(count):
              for f in self.opts.fields + self.opts.many_to_many:
                  if follow.get(f.name, False):
                      prefix = '%s.%d.' % (self.var_name, i)
                      fields.extend(f.get_manipulator_fields(self.opts, manipulator, change,
                                                             name_prefix=prefix, rel=True))
          return fields
  
      def __repr__(self):
          return "<RelatedObject: %s related to %s>" % (self.name, self.field.name)
  
      def bind(self, field_mapping, original, bound_related_object_class=BoundRelatedObject):
          return bound_related_object_class(self, field_mapping, original)
  
      def get_accessor_name(self):
          # This method encapsulates the logic that decides what name to give an
          # accessor descriptor that retrieves related many-to-one or
          # many-to-many objects. It uses the lower-cased object_name + "_set",
          # but this can be overridden with the "related_name" option.
          if self.field.rel.multiple:
              # If this is a symmetrical m2m relation on self, there is no reverse accessor.
              if getattr(self.field.rel, 'symmetrical', False) and self.model == self.parent_model:
                  return None
              return self.field.rel.related_name or (self.opts.object_name.lower() + '_set')
          else:
              return self.field.rel.related_name or (self.opts.object_name.lower())
  