django एक-से-एक संबंध बच्चे के ऑब्जेक्ट को नाम कैसे चिह्नित करता है?

Question

दस्तावेज़ों में एक उदाहरण के अलावा, मुझे कोई दस्तावेज नहीं मिल रहा है कि कैसे django नाम चुनता है जिसके साथ कोई मूल वस्तु से बच्चे ऑब्जेक्ट तक पहुंच सकता है। उनके उदाहरण में, वे निम्न कार्य करें:

class Place(models.Model): 
     name = models.CharField(max_length=50) 
     address = models.CharField(max_length=80) 

     def __unicode__(self): 
      return u"%s the place" % self.name 

    class Restaurant(models.Model): 
     place = models.OneToOneField(Place, primary_key=True) 
     serves_hot_dogs = models.BooleanField() 
     serves_pizza = models.BooleanField() 

     def __unicode__(self): 
      return u"%s the restaurant" % self.place.name 

    # Create a couple of Places. 
    >>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton') 
    >>> p1.save() 
    >>> p2 = Place(name='Ace Hardware', address='1013 N. Ashland') 
    >>> p2.save() 

    # Create a Restaurant. Pass the ID of the "parent" object as this object's ID. 
    >>> r = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False) 
    >>> r.save() 

    # A Restaurant can access its place. 
    >>> r.place 
    <Place: Demon Dogs the place> 
    # A Place can access its restaurant, if available. 
    >>> p1.restaurant 

तो उनके उदाहरण में, वे बस p1.restaurant स्पष्ट रूप से उस नाम को परिभाषित करने के बिना कहते हैं। Django मानता है कि नाम लोअरकेस के साथ शुरू होता है। क्या होता है यदि ऑब्जेक्ट नाम में एक से अधिक शब्द हैं, जैसे FancyRestaurant?

साइड नोट: मैं इस तरह से उपयोगकर्ता ऑब्जेक्ट को विस्तारित करने का प्रयास कर रहा हूं। क्या यह समस्या हो सकती है?

Answer 1

यदि आप कस्टम related_name को परिभाषित करते हैं तो यह इसका उपयोग करेगा, अन्यथा यह पूरे मॉडल नाम को कम करेगा (आपके उदाहरण .fancyrestaurant में)। कैसे OneToOneField calls it

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()) 

और यहाँ है::

class OneToOneField(ForeignKey): 
    ... snip ... 

    def contribute_to_related_class(self, cls, related): 
     setattr(cls, related.get_accessor_name(), 
       SingleRelatedObjectDescriptor(related)) 

opts.object_name (django.db.models.related.get_accessor_name में संदर्भित) defaults to cls.__name__django.db.models.related code में और ब्लॉक देखें।

साइड टिप्पणी का सवाल है: मैं इस तरह से उपयोगकर्ता वस्तु का विस्तार करने की कोशिश कर रहा हूँ। क्या यह समस्या हो सकती है कि समस्या है?

नहीं, यह नहीं होगा, User मॉडल सिर्फ एक नियमित डीजेंगो मॉडल है। बस related_name टकराव के लिए देखें।