1 class BoundRelatedObject(object):

     2     def __init__(self, related_object, field_mapping, original):

     3         self.relation = related_object

     4         self.field_mappings = field_mapping[related_object.name]

     5 

     6     def template_name(self):

     7         raise NotImplementedError

     8 

     9     def __repr__(self):

    10         return repr(self.__dict__)

    11 

    12 class RelatedObject(object):

    13     def __init__(self, parent_model, model, field):

    14         self.parent_model = parent_model

    15         self.model = model

    16         self.opts = model._meta

    17         self.field = field

    18         self.name = '%s:%s' % (self.opts.app_label, self.opts.module_name)

    19         self.var_name = self.opts.object_name.lower()

    20 

    21     def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False):

    22         # Defer to the actual field definition for db prep

    23         return self.field.get_db_prep_lookup(lookup_type, value,

    24                         connection=connection, prepared=prepared)

    25 

    26     def editable_fields(self):

    27         "Get the fields in this class that should be edited inline."

    28         return [f for f in self.opts.fields + self.opts.many_to_many if f.editable and f != self.field]

    29 

    30     def __repr__(self):

    31         return "<RelatedObject: %s related to %s>" % (self.name, self.field.name)

    32 

    33     def bind(self, field_mapping, original, bound_related_object_class=BoundRelatedObject):

    34         return bound_related_object_class(self, field_mapping, original)

    35 

    36     def get_accessor_name(self):

    37         # This method encapsulates the logic that decides what name to give an

    38         # accessor descriptor that retrieves related many-to-one or

    39         # many-to-many objects. It uses the lower-cased object_name + "_set",

    40         # but this can be overridden with the "related_name" option.

    41         if self.field.rel.multiple:

    42             # If this is a symmetrical m2m relation on self, there is no reverse accessor.

    43             if getattr(self.field.rel, 'symmetrical', False) and self.model == self.parent_model:

    44                 return None

    45             return self.field.rel.related_name or (self.opts.object_name.lower() + '_set')

    46         else:

    47             return self.field.rel.related_name or (self.opts.object_name.lower())

    48 

    49     def get_cache_name(self):

    50         return "_%s_cache" % self.get_accessor_name()