Help on module pydoctest.geotest.models in pydoctest.geotest:

NAME
    pydoctest.geotest.models - Models to test pydoc.

FILE
    /home/manolo/sandbox/sprint/trunk/pydoctest/geotest/models.py

DESCRIPTION
    I'm writing some DocStrings to test pydoc and geodjango.

CLASSES
    django.db.models.base.Model(__builtin__.object)
        TestGeoModel
    
    class TestGeoModel(django.db.models.base.Model)
     |  This is a geographic model.
     |  
     |  It is very complicated, thus the enormously long docstring.
     |  
     |  Method resolution order:
     |      TestGeoModel
     |      django.db.models.base.Model
     |      __builtin__.object
     |  
     |  Methods defined here:
     |  
     |  __unicode__(self)
     |      Get a unicode representation of this object (it's just its name).
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  DoesNotExist = <class 'pydoctest.geotest.models.DoesNotExist'>
     |  
     |  
     |  MultipleObjectsReturned = <class 'pydoctest.geotest.models.MultipleObj...
     |  
     |  
     |  objects = <django.db.models.manager.Manager object at 0x93f252c>
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from django.db.models.base.Model:
     |  
     |  __eq__(self, other)
     |  
     |  __hash__(self)
     |  
     |  __init__(self, *args, **kwargs)
     |  
     |  __ne__(self, other)
     |  
     |  __reduce__(self)
     |      Provide pickling support. Normally, this just dispatches to Python's
     |      standard handling. However, for models with deferred field loading, we
     |      need to do things manually, as they're dynamically created classes and
     |      only module-level classes can be pickled by the default path.
     |  
     |  __repr__(self)
     |  
     |  __str__(self)
     |  
     |  clean(self)
     |      Hook for doing any extra model-wide validation after clean() has been
     |      called on every field by self.clean_fields. Any ValidationError raised
     |      by this method will not be associated with a particular field; it will
     |      have a special-case association with the field defined by NON_FIELD_ERRORS.
     |  
     |  clean_fields(self, exclude=None)
     |      Cleans all fields and raises a ValidationError containing message_dict
     |      of all validation errors if any occur.
     |  
     |  date_error_message(self, lookup_type, field, unique_for)
     |  
     |  delete(self, using=None)
     |  
     |  full_clean(self, exclude=None)
     |      Calls clean_fields, clean, and validate_unique, on the model,
     |      and raises a ``ValidationError`` for any errors that occured.
     |  
     |  prepare_database_save(self, unused)
     |  
     |  save(self, force_insert=False, force_update=False, using=None)
     |      Saves the current instance. Override this in a subclass if you want to
     |      control the saving process.
     |      
     |      The 'force_insert' and 'force_update' parameters can be used to insist
     |      that the "save" must be an SQL insert or update (or equivalent for
     |      non-SQL backends), respectively. Normally, they should not be set.
     |  
     |  save_base(self, raw=False, cls=None, origin=None, force_insert=False, force_update=False, using=None)
     |      Does the heavy-lifting involved in saving. Subclasses shouldn't need to
     |      override this method. It's separate from save() in order to hide the
     |      need for overrides of save() to pass around internal-only parameters
     |      ('raw', 'cls', and 'origin').
     |  
     |  serializable_value(self, field_name)
     |      Returns the value of the field name for this instance. If the field is
     |      a foreign key, returns the id value, instead of the object. If there's
     |      no Field object with this name on the model, the model attribute's
     |      value is returned directly.
     |      
     |      Used to serialize a field's value (in the serializer, or form output,
     |      for example). Normally, you would just access the attribute directly
     |      and not use this method.
     |  
     |  unique_error_message(self, model_class, unique_check)
     |  
     |  validate_unique(self, exclude=None)
     |      Checks unique constraints on the model and raises ``ValidationError``
     |      if any failed.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from django.db.models.base.Model:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  pk
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from django.db.models.base.Model:
     |  
     |  __metaclass__ = <class 'django.db.models.base.ModelBase'>
     |      Metaclass for all models.