Access to persistent data

--------------------------

Python-level access to persistent data is provided by the

:class:`Entity <cubicweb.entity>` class.

.. XXX this part is not clear. refactor it.

An entity class is bound to a schema entity type. Descriptors are added when

classes are registered in order to initialize the class according to its schema:

* the attributes defined in the schema appear as attributes of these classes

* the relations defined in the schema appear as attributes of these classes,

  but are lists of instances

`Formatting and output generation`:

* :meth:`view(__vid, __registry='views', **kwargs)`, applies the given view to the entity

  (and returns a unicode string)

* :meth:`absolute_url(*args, **kwargs)`, returns an absolute URL including the base-url

* :meth:`rest_path()`, returns a relative REST URL to get the entity

* :meth:`printable_value(attr, value=_marker, attrtype=None, format='text/html', displaytime=True)`,

  returns a string enabling the display of an attribute value in a given format

  (the value is automatically recovered if necessary)

`Data handling`:

* :meth:`as_rset()`, converts the entity into an equivalent result set simulating the

  request `Any X WHERE X eid _eid_`

* :meth:`complete(skip_bytes=True)`, executes a request that recovers at

  once all the missing attributes of an entity

* :meth:`get_value(name)`, returns the value associated to the attribute name given

  in parameter

* :meth:`related(rtype, role='subject', limit=None, entities=False)`,

  returns a list of entities related to the current entity by the

  relation given in parameter

* :meth:`unrelated(rtype, targettype, role='subject', limit=None)`,

  returns a result set corresponding to the entities not (yet)

  related to the current entity by the relation given in parameter

  and satisfying its constraints

* :meth:`cw_set(**kwargs)`, updates entity's attributes and/or relation with the

  corresponding values given named parameters. To set a relation where this

  entity is the object of the relation, use `reverse_<relation>` as argument

  name.  Values may be an entity, a list of entities, or None (meaning that all

  relations of the given type from or to this object should be deleted).

* :meth:`copy_relations(ceid)`, copies the relations of the entities having the eid

  given in the parameters on the current entity

* :meth:`cw_delete()` allows to delete the entity

The :class:`AnyEntity` class

----------------------------

To provide a specific behavior for each entity, we can define a class

inheriting from `cubicweb.entities.AnyEntity`. In general, we define this class

in `mycube.entities` module (or in a submodule if we want to split code among

multiple files) so that it will be available on both server and client side.

The class `AnyEntity` is a sub-class of Entity that add methods to it,

and helps specializing (by further subclassing) the handling of a

given entity type.

Most methods defined for `AnyEntity`, in addition to `Entity`, add

support for the `Dublin Core`_ metadata.

.. _`Dublin Core`: http://dublincore.org/

`Standard meta-data (Dublin Core)`:

* :meth:`dc_title()`, returns a unicode string corresponding to the

  meta-data `Title` (used by default is the first non-meta attribute

  of the entity schema)

* :meth:`dc_long_title()`, same as dc_title but can return a more

  detailed title

* :meth:`dc_description(format='text/plain')`, returns a unicode string

  corresponding to the meta-data `Description` (looks for a

  description attribute by default)

* :meth:`dc_authors()`, returns a unicode string corresponding to the meta-data

  `Authors` (owners by default)

* :meth:`dc_creator()`, returns a unicode string corresponding to the

  creator of the entity

* :meth:`dc_date(date_format=None)`, returns a unicode string corresponding to

  the meta-data `Date` (update date by default)

* :meth:`dc_type(form='')`, returns a string to display the entity type by

  specifying the preferred form (`plural` for a plural form)

* :meth:`dc_language()`, returns the language used by the entity

Inheritance

-----------

When describing a data model, entities can inherit from other entities as is

common in object-oriented programming.

You have the possibility to redefine whatever pleases you, as follow:

.. sourcecode:: python

    from cubes.OTHER_CUBE import entities

    class EntityExample(entities.EntityExample):

        def dc_long_title(self):

            return '%s (%s)' % (self.name, self.description)

The most specific entity definition will always the one used by the

ORM. For instance, the new EntityExample above in mycube replaces the

one in OTHER_CUBE. These types are stored in the `etype` section of

the `vregistry`.

Notice this is different than yams schema inheritance, which is an

experimental undocumented feature.

Application logic

-----------------

While a lot of custom behaviour and application logic can be

implemented using entity classes, the programmer must be aware that

adding new attributes and method on an entity class adds may shadow

schema-level attribute or relation definitions.

To keep entities clean (mostly data structures plus a few universal

methods such as listed above), one should use `adapters` (see

:ref:`adapters`).