# -*- coding: UTF-8 -*-
# generated by lino.sphinxcontrib.help_text_builder
from __future__ import unicode_literals
from django.utils.translation import ugettext_lazy as _

help_texts = {
    'lino.AppConfig' : _("""This is the only django.apps.AppConfig object used by
Lino."""),
    'lino.api.doctest.HttpQuery.expected_rows' : _("""Alias for field number 3"""),
    'lino.api.doctest.HttpQuery.json_fields' : _("""Alias for field number 2"""),
    'lino.api.doctest.HttpQuery.kwargs' : _("""Alias for field number 4"""),
    'lino.api.doctest.HttpQuery.url_base' : _("""Alias for field number 1"""),
    'lino.api.doctest.HttpQuery.username' : _("""Alias for field number 0"""),
    'lino.api.selenium.Album' : _("""Generates one directory of screenshots images and their index.rst
file."""),
    'lino.api.selenium.Album.stabilize' : _("""Wait until the screen has become stable.  This measn that the
browser has processed all Javascript, including ExtJS.onReady,
that all AJAX requests have finised."""),
    'lino.management.commands.initdb.Command' : _("""Flush the database and load the specified fixtures."""),
    'lino.management.commands.makemigdump.Command' : _("""Create a dump for migration tests."""),
    'lino.management.commands.prep.Command' : _("""Flushes the database and loads the default demo fixtures."""),
    'lino.Contactable' : _("""Mixin for models that represent somebody who can be contacted by
email."""),
    'lino.Contactable.get_as_user' : _("""Return the user object representing this contactable."""),
    'lino.Phonable' : _("""Mixin for models that represent somebody who can be contacted by
phone."""),
    'lino.Modified' : _("""Adds a a timestamp field which holds the last modification time of
every individual database object."""),
    'lino.Modified.modified' : _("""The time when this database object was last modified."""),
    'lino.Modified.auto_touch' : _("""Whether to touch objects automatically when saving them."""),
    'lino.Created' : _("""Adds a a timestamp field which holds the creation time of every
individual database object."""),
    'lino.Created.created' : _("""The time when this object was created."""),
    'lino.CreatedModified' : _("""Adds two timestamp fields created and modified."""),
    'lino.ProjectRelated' : _("""Mixin for models that are related to a "project". This adds a
field named project and related default behaviour."""),
    'lino.ProjectRelated.project' : _("""Pointer to the project to which this object is related."""),
    'lino.ProjectRelated.update_owned_instance' : _("""When a project-related object controls
another project-related object, then the controlled
automatically inherits the project of its controller."""),
    'lino.dupable.CheckedSubmitInsert' : _("""Like the standard lino.core.actions.SubmitInsert, but adds
a confirmation if there is a possible duplicate record."""),
    'lino.dupable.PhoneticWordBase' : _("""Base class for the table of phonetic words of a given dupable
model. For every (non-abstract) dupable model there must be a
subclass of PhoneticWordBase.
The subclass must define a field
owner which points to the Dupable, and the Dupable's
dupable_word_model must point to its subclass
of PhoneticWordBase."""),
    'lino.dupable.Dupable' : _("""Base class for models that can be "dupable"."""),
    'lino.dupable.Dupable.submit_insert' : _("""A dupable model has its
submit_insert action
overridden by CheckedSubmitInsert, a extended variant of
the action which checks for duplicate rows and asks a user
confirmation when necessary."""),
    'lino.dupable.Dupable.dupable_words_field' : _("""The name of a CharField on this model which holds the full-text
description that is being tested for duplicates."""),
    'lino.dupable.Dupable.dupable_word_model' : _("""Full name of the model used to hold dupable words for instances of
this model.  Applications can specify a string which will be
resolved at startup to the model's class object."""),
    'lino.dupable.Dupable.on_analyze' : _("""Setup the dupable_word_model attribute.  This will be
called only on concrete subclasses."""),
    'lino.dupable.Dupable.dupable_matches_required' : _("""Return the minimum number of words that must sound alike before
two rows should be considered similar."""),
    'lino.dupable.Dupable.update_dupable_words' : _("""Update the phonetic words of this row."""),
    'lino.dupable.Dupable.find_similar_instances' : _("""Return a queryset or yield a list of similar objects."""),
    'lino.dupable.DupableChecker' : _("""Checks for the following repairable problem:"""),
    'lino.dupable.DupableChecker.model' : _("""alias of Dupable"""),
    'lino.dupable.SimilarObjects' : _("""Shows the other objects which are similar to this one."""),
    'lino.dupable.SimilarObjects.master' : _("""alias of lino.core.model.Model"""),
    'lino.duplicable.Duplicate' : _("""Duplicate the selected row."""),
    'lino.duplicable.Duplicate.run_from_ui' : _("""This actually runs the action."""),
    'lino.duplicable.Duplicable' : _("""Adds a row action "Duplicate" which duplicates (creates a clone
of) the object it was called on."""),
    'lino.human.Human' : _("""Base class for models that represent a human."""),
    'lino.human.Human.title' : _("""Used to specify a professional position or academic
qualification like "Dr." or "PhD"."""),
    'lino.human.Human.first_name' : _("""The first name, also known as given name."""),
    'lino.human.Human.last_name' : _("""The last name, also known as family name."""),
    'lino.human.Human.middle_name' : _("""A space-separated list of all middle names."""),
    'lino.human.Human.gender' : _("""The sex of this person (male or female)."""),
    'lino.human.Human.mf' : _("""Taking three parameters m, f and u of any type, returns one
of them depending on whether this Person is male, female or of
unknown gender."""),
    'lino.human.Human.get_last_name_prefix' : _("""May be used for handling special of titles (e.g. "Cardinal",
"Graf") which come before the last name (not before the first
name)."""),
    'lino.human.Human.get_full_name' : _("""Returns a one-line string composed of salutation,
first_name and last_name."""),
    'lino.human.Human.full_name' : _("""Returns a one-line string composed of salutation,
first_name and last_name."""),
    'lino.human.Human.format_family_member' : _("""Used in humanlinks.LinksByHuman and in
households.SiblingsByPerson."""),
    'lino.human.Born' : _("""Abstract base class that adds a birth_date field and a virtual
field "Age"."""),
    'lino.human.Born.birth_date' : _("""An IncompleteDateField."""),
    'lino.human.Born.age' : _("""Virtual field displaying the age in years."""),
    'lino.human.Born.get_age' : _("""Return the age (in years) of this human.  See
lino.utils.IncompleteDateField.get_age()."""),
    'lino.human.Born.get_exact_age' : _("""Return the age as a datetime.timedelta object."""),
    'lino.periods.CombinedDateTime' : _("""Mixin for models which have at least one couple of date and time
fields which form a kind of editable timestamp field."""),
    'lino.periods.CombinedDateTime.get_time_zone' : _("""The time zone for the date and time fields in this model."""),
    'lino.periods.CombinedDateTime.set_datetime' : _("""Given a datetime value, update the two corresponding fields
FOO_date and FOO_time (where FOO is specified in name which
must be either "start" or "end")."""),
    'lino.periods.CombinedDateTime.get_datetime' : _("""Return a datetime value from the two corresponding
date and time fields."""),
    'lino.periods.Started' : _("""Adds two fields start_date and start_time."""),
    'lino.periods.Started.save' : _("""Fills default value "today" to start_date"""),
    'lino.periods.Ended' : _("""Mixin for models with two fields end_date and
end_time."""),
    'lino.periods.Ended.get_duration' : _("""Return the duration in hours."""),
    'lino.periods.DateRange' : _("""Mixin for models which represent a period whose start and end are
date fields."""),
    'lino.periods.ObservedDateRange' : _("""lino.core.param_panel.ParameterPanel with two fields
start_date and end_date which default to empty."""),
    'lino.periods.Yearly' : _("""An ObservedDateRange for which start_date defaults to Jan
1st and end_date to Dec 31 of the current year."""),
    'lino.periods.Monthly' : _("""An ObservedDateRange which defaults to the current month."""),
    'lino.periods.Today' : _("""A ParameterPanel
with a field today which defaults to today."""),
    'lino.polymorphic.Polymorphic' : _("""Mixin for models that use Multiple Table Inheritance to implement
polymorphism."""),
    'lino.polymorphic.Polymorphic.mti_navigator' : _("""A virtual field which defines buttons for switching between the
different views."""),
    'lino.polymorphic.Polymorphic.get_mti_child' : _("""Return the specified specialization or None."""),
    'lino.polymorphic.Polymorphic.disable_delete' : _("""Overrides lino.core.model.Model.disable_delete()."""),
    'lino.ref.Referrable' : _("""Mixin for things that have a unique reference, i.e. an identifying
name used by humans to refer to an individual object."""),
    'lino.ref.Referrable.ref' : _("""The reference. This must be either empty or unique."""),
    'lino.ref.Referrable.ref_max_length' : _("""The preferred width of the ref field."""),
    'lino.ref.Referrable.on_duplicate' : _("""Before saving a duplicated object for the first time, we must
change the ref in order to avoid an IntegrityError."""),
    'lino.ref.Referrable.get_by_ref' : _("""Return the object identified by the given reference."""),
    'lino.ref.Referrable.quick_search_filter' : _("""Overrides the default behaviour defined in
lino.core.model.Model.quick_search_filter(). For
Referrable objects, when quick-searching for a text containing
only digits, the user usually means the ref and not
the primary key."""),
    'lino.ref.StructuredReferrable' : _("""A referrable whose ref field is used to define a hierarchical structure."""),
    'lino.ref.StructuredReferrable.ref_description' : _("""Displays the structured together with the designation."""),
    'lino.ref.StructuredReferrable.get_designation' : _("""Return the "designation" part (without the reference)."""),
    'lino.registrable.RegistrableState' : _("""Base class"""),
    'lino.registrable.RegistrableState.is_editable' : _("""Whether the registrable object having this state should be
editable or not."""),
    'lino.registrable.Registrable' : _("""Base class to anything that may be "registered" and "deregistered"
(e.g. Invoices, Vouchers, Declarations, Reservations,...).
"Registered" means "this object has been taken account of".
Registered objects are not editable."""),
    'lino.registrable.Registrable.state' : _("""The ChoiceList of this  field must have at least two items
named "draft" and "registered".
There may be additional states.
Every state must have an extra attribute "is_editable"."""),
    'lino.registrable.Registrable.get_registrable_fields' : _("""Return a list of the fields which are disabled when this is
registered (i.e. state is not editable)."""),
    'lino.registrable.Registrable.get_row_permission' : _("""Only rows in an editable state may be edited."""),
    'lino.registrable.Registrable.register' : _("""Register this object.  The base implementation just sets the state
to "registered"."""),
    'lino.registrable.Registrable.deregister' : _("""Deregister this object.  The base implementation just sets the
state to "draft"."""),
    'lino.sequenced.MoveByN' : _("""Move this row N rows upwards or downwards."""),
    'lino.sequenced.MoveUp' : _("""Move this row one row upwards."""),
    'lino.sequenced.MoveDown' : _("""Move this row one row downwards."""),
    'lino.sequenced.DuplicateSequenced' : _("""Duplicate this row."""),
    'lino.sequenced.Sequenced' : _("""Mixin for models that have a field seqno containing a
"sequence number"."""),
    'lino.sequenced.Sequenced.seqno' : _("""The sequence number of this item with its parent."""),
    'lino.sequenced.Sequenced.duplicate' : _("""Create a duplicate of this object and insert the new object
below this one."""),
    'lino.sequenced.Sequenced.move_up' : _("""Exchange the seqno of this item and the previous item."""),
    'lino.sequenced.Sequenced.move_down' : _("""Exchange the seqno of this item and the next item."""),
    'lino.sequenced.Sequenced.move_buttons' : _("""Displays buttons for certain actions on this row:"""),
    'lino.sequenced.Sequenced.move_action_names' : _("""The names of the actions to display in the move_buttons
column."""),
    'lino.sequenced.Sequenced.move_by_n' : _("""The MoveByN action on this object."""),
    'lino.sequenced.Sequenced.get_siblings' : _("""Return a Django Queryset with all siblings of this, or None if
this is a root element which cannot have any siblings."""),
    'lino.sequenced.Sequenced.set_seqno' : _("""Initialize seqno to the seqno of eldest sibling + 1."""),
    'lino.sequenced.Sequenced.seqno_changed' : _("""If the user manually assigns a seqno."""),
    'lino.sequenced.Hierarchical' : _("""Abstract model mixin for things that have a "parent" and
"siblings"."""),
    'lino.sequenced.Hierarchical.get_parental_line' : _("""Return an ordered list of all ancestors of this instance."""),
    'lino.sequenced.Hierarchical.whole_clan' : _("""Return a set of this instance and all children and grandchildren."""),
    'lino.uploadable.Uploadable' : _("""Mixin for objects that represent an uploadable file."""),
    'lino.uploadable.Uploadable.file' : _("""Pointer to the file itself (a Django FileField)."""),
    'lino.uploadable.Uploadable.mimetype' : _("""The Media type
of the file.  See also this thread
about length of MIME type field."""),
    'lino.modlib.about.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.bootstrap3.renderer.Renderer' : _("""A  HTML render that uses Bootstrap3."""),
    'lino.modlib.bootstrap3.views.List' : _("""Render a list of records."""),
    'lino.modlib.bootstrap3.views.Element' : _("""Render a single record."""),
    'lino.modlib.bootstrap3.views.Index' : _("""Render the main page."""),
    'lino.modlib.changes.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.changes.ChangeTypes' : _("""The list of possible choices for the type field
of a Change."""),
    'lino.modlib.changes.Change' : _("""A registered change in the database."""),
    'lino.modlib.changes.Change.master' : _("""The database object which acts as "master"."""),
    'lino.modlib.changes.Change.object' : _("""The database object which has been modified."""),
    'lino.modlib.changes.Changes' : _("""The default table for Change."""),
    'lino.modlib.changes.Changes.model' : _("""alias of Change"""),
    'lino.modlib.changes.ChangesByObject' : _("""Slave Table showing the direct changes related to the current
object."""),
    'lino.modlib.changes.ChangesByObject.model' : _("""alias of Change"""),
    'lino.modlib.changes.ChangesByMaster' : _("""Slave Table showing the changes related to the current object,
including those applied to "child" objects."""),
    'lino.modlib.changes.ChangesByMaster.model' : _("""alias of Change"""),
    'lino.modlib.checkdata.Plugin' : _("""The config descriptor for this plugin."""),
    'lino.modlib.checkdata.Plugin.responsible_user' : _("""The username
of the main checkdata responsible, i.e. a designated
user who will be attributed to data problems for which
no specific responible could be designated (returned by the
checker's get_responsible_user
method)."""),
    'lino.modlib.checkdata.Plugin.on_plugins_loaded' : _("""Set responsible_user to "'robin' if this is a demo site
(is_demo_site)."""),
    'lino.modlib.checkdata.Checker' : _("""Base class for the choices of Checkers."""),
    'lino.modlib.checkdata.Checker.model' : _("""The model to be checked.  If this is a string, Lino will resolve it at startup."""),
    'lino.modlib.checkdata.Checker.activate' : _("""Application developers must call this on their subclass in order to
"register" or "activate" it."""),
    'lino.modlib.checkdata.Checker.check_instance' : _("""Run get_checkdata_problems() on this checker for the given
instance."""),
    'lino.modlib.checkdata.Checker.get_checkable_models' : _("""Return a list of the models to check."""),
    'lino.modlib.checkdata.Checker.update_problems' : _("""Update the problems of this checker for the specified object."""),
    'lino.modlib.checkdata.Checker.get_checkdata_problems' : _("""Return or yield a series of (fixable, message) tuples, each
describing a data problem. fixable is a boolean
saying whether this problem can be automatically fixed. And if
fix is True, this method is also responsible for fixing
it."""),
    'lino.modlib.checkdata.Checker.get_responsible_user' : _("""The user to
be considered responsible for problems detected by this
checker on the given database object obj."""),
    'lino.modlib.checkdata.Checkers' : _("""The list of data problem types known by this application."""),
    'lino.modlib.checkdata.Checkers.item_class' : _("""alias of Checker"""),
    'lino.modlib.checkdata.UpdateProblemsByController' : _("""Updates the table of data problems for a given database
object, also removing those messages which no longer exist. This
action does not change anything else in the database."""),
    'lino.modlib.checkdata.FixProblemsByController' : _("""Update data problems, repairing those which are
automatically fixable."""),
    'lino.modlib.checkdata.Problem' : _("""Represents a detected data problem."""),
    'lino.modlib.checkdata.Problem.checker' : _("""The Checker which reported
this problem."""),
    'lino.modlib.checkdata.Problem.message' : _("""The message text. This is a concatenation of all messages that
were yeld by the checker."""),
    'lino.modlib.checkdata.Problem.user' : _("""The user reponsible
for fixing this problem."""),
    'lino.modlib.checkdata.Problems' : _("""The base table for Problem objects."""),
    'lino.modlib.checkdata.Problems.model' : _("""alias of Problem"""),
    'lino.modlib.checkdata.AllProblems' : _("""Show all data problems."""),
    'lino.modlib.checkdata.AllProblems.model' : _("""alias of Problem"""),
    'lino.modlib.checkdata.ProblemsByOwner' : _("""Show data problems related to this database object."""),
    'lino.modlib.checkdata.ProblemsByOwner.model' : _("""alias of Problem"""),
    'lino.modlib.checkdata.ProblemsByChecker' : _("""Show the data problems by checker."""),
    'lino.modlib.checkdata.ProblemsByChecker.master' : _("""alias of lino.modlib.checkdata.choicelists.Checker"""),
    'lino.modlib.checkdata.ProblemsByChecker.model' : _("""alias of Problem"""),
    'lino.modlib.checkdata.MyProblems' : _("""Shows the data problems assigned to this user."""),
    'lino.modlib.checkdata.MyProblems.model' : _("""alias of Problem"""),
    'lino.modlib.checkdata.roles.CheckdataUser' : _("""Can see data problems."""),
    'lino.modlib.comments.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.dashboard.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.dashboard.UpdateWidgets' : _("""Create or update the dashboard widgets for this user."""),
    'lino.modlib.export_excel.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.extjs.Plugin' : _("""Extends lino.core.plugin.Plugin."""),
    'lino.modlib.extjs.Plugin.enter_submits_form' : _("""Whether the ENTER key (or CTRL+ENTER when in a
textarea field) should submit the form."""),
    'lino.modlib.extjs.Plugin.use_statusbar' : _("""Whether to use a status bar to display certain messages to the user.
Default is False since currently this is not really useful."""),
    'lino.modlib.extjs.Plugin.media_name' : _("""The URL from where to include the ExtJS library files."""),
    'lino.modlib.extjs.Plugin.autorefresh_seconds' : _("""Number of seconds to wait between two refreshes when autorefresh is
activated. Default is 60. Set this to 0 in order to deactivate
the autorefresh button."""),
    'lino.modlib.extjs.Plugin.media_root' : _("""Path to the ExtJS root directory.  Only used when
media_base_url is None, and when the media directory has
no symbolic link named extjs pointing to the ExtJS root
directory."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer' : _("""An HTML renderer that uses the ExtJS Javascript toolkit."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.py2js_converter' : _("""Additional converting logic for serializing Python values to json."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.window_action_button' : _("""Return a HTML chunk for a button that will execute this action
using a Javascript link to this action."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.quick_manage_toolbar' : _("""Returns a HTML chunk that displays a "toolbar" with a series of
"quick manage buttons": one "Insert" and another to open the
table."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.unused_insert_button' : _("""Called via lino.core.requests.ActionRequest.insert_button()."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.action_call_on_instance' : _("""Note that ba.actor may differ from ar.actor when defined on a
different actor. Remember e.g. the "Must read eID card" action
button in eid_info of newcomers.NewClients (20140422)."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.get_request_url' : _("""Called from ActionRequest.absolute_url() used in Team.eml.html"""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.html_text' : _("""Wrap the given html fragment into a <div class="htmlText">
which specifies that this fragment contains simple html text
inside an ExtJS component.  This is required because ExtJS
does a lot of CSS magic which neutralizes the "usual" effects
of most html tags."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.html_page' : _("""Return a string with the index page.  Content is mostly in the
extjs/index.html template."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.html_page_main_window' : _("""Called from lino/modlib/extjs/config/extjs/index.html."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.html_page_user' : _("""Build the "user menu", i.e. the menu in the top right corner."""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.toolbar' : _("""This also manages action groups"""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.build_on_render' : _("""dh is a FormLayout or a ColumnsLayout"""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.js_render_custom_action' : _("""Defines the non-window action handler used by
row_action_button()"""),
    'lino.modlib.extjs.ext_renderer.ExtRenderer.linolib_intro' : _("""Called from linolib.js."""),
    'lino.modlib.extjs.views.AdminIndex' : _("""Similar to PlainIndex"""),
    'lino.modlib.extjs.views.unused_Authenticate' : _("""This view is being used when remote_user_header is
empty (and user_model not).
lino.core.auth.SessionUserMiddleware"""),
    'lino.modlib.extjs.views.Restful' : _("""Used to collaborate with a restful Ext.data.Store."""),
    'lino.modlib.gfks.Plugin' : _("""Base class for this plugin."""),
    'lino.modlib.importfilters.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.jinja.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.jinja.Plugin.post_site_startup' : _("""This is being called from
lino.core.kernel.Kernel.kernel_startup()."""),
    'lino.modlib.jinja.Plugin.list_templates' : _("""Return a list of possible choices for a field that contains a
template name."""),
    'lino.modlib.jinja.Plugin.render_from_request' : _("""Render the named Jinja template, replacing ar.renderer by the
Site's default renderer.
Adds some more context names."""),
    'lino.modlib.jinja.Plugin.render_jinja' : _("""Render the named Jinja template, replacing ar.renderer by the
Jinja renderer."""),
    'lino.modlib.jinja.loader.DjangoJinjaTemplate' : _("""used e.g. to render /lino/lino/config/500.html"""),
    'lino.modlib.languages.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.memo.Plugin' : _("""Base class for this plugin."""),
    'lino.modlib.memo.Plugin.parser' : _("""An instance of lino.modlib.memo.parser.Parser."""),
    'lino.modlib.memo.Plugin.front_end' : _("""The front end to use when writing previews."""),
    'lino.modlib.notify.Plugin' : _("""See lino.core.plugin.Plugin."""),
    'lino.modlib.notify.Plugin.remove_after' : _("""Automatically remove notification messages after x hours."""),
    'lino.modlib.notify.Plugin.keep_unseen' : _("""Whether to keep unseen messages when removing old messages
according to remove_after."""),
    'lino.modlib.office.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.printing.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.restful.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.smtpd.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.summaries.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.summaries.Plugin.start_year' : _("""The first year for which summaries should be computed."""),
    'lino.modlib.summaries.Plugin.end_year' : _("""The last year for which summaries should be computed."""),
    'lino.modlib.system.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.system.YesNo' : _("""A choicelist with two values "Yes" and "No"."""),
    'lino.modlib.system.Genders' : _("""Defines the two possible choices "male" and "female"
for the gender of a person."""),
    'lino.modlib.system.ObservedEvent' : _("""Base class for choices of "observed event"-style choicelists."""),
    'lino.modlib.system.ObservedEvent.add_filter' : _("""Add a filter to the given Django queryset. The given obj must be
either a datetime.date object or must have two attributes
start_date and end_date. The easiest way is to have it an
instance of DateRange or DateRangeValue."""),
    'lino.modlib.system.PeriodEvents' : _("""The list of things you can observe on a
lino.mixins.periods.DateRange."""),
    'lino.modlib.system.BuildSiteCache' : _("""Rebuild the site cache.
This action is available on About."""),
    'lino.modlib.system.SiteConfigManager' : _("""Always return the cached instance which holds the one and only
database instance."""),
    'lino.modlib.system.SiteConfig' : _("""This model has exactly one instance, used to store persistent
global site parameters.  Application code sees this instance as
the settings.SITE.site_config property."""),
    'lino.modlib.system.SiteConfig.default_build_method' : _("""The default build method to use when rendering printable documents."""),
    'lino.modlib.system.SiteConfig.simulate_today' : _("""A constant user-defined date to be substituted as current
system date."""),
    'lino.modlib.system.SiteConfig.site_company' : _("""The organisation who runs this site.  This is used e.g. when
printing your address in certain documents or reports.  Or
newly created partners inherit the country of the site owner."""),
    'lino.modlib.system.SiteConfig.hide_events_before' : _("""If this is not empty, any calendar events before that date are
being hidden in certain places."""),
    'lino.modlib.system.SiteConfig.update' : _("""Set some field of the SiteConfig object and store it to the
database."""),
    'lino.modlib.system.SiteConfigs' : _("""The table used to present the SiteConfig row in a Detail form.
See also lino.Lino.get_site_config().
Deserves more documentation."""),
    'lino.modlib.system.SiteConfigs.model' : _("""alias of SiteConfig"""),
    'lino.modlib.tinymce.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.tinymce.Plugin.document_domain' : _("""The domain name of this production site."""),
    'lino.modlib.tinymce.Plugin.window_width' : _("""The initial width of the window to use when editing in own
window."""),
    'lino.modlib.tinymce.Plugin.window_height' : _("""The initial height of the window to use when editing in own
window."""),
    'lino.modlib.tinymce.Plugin.field_buttons' : _("""The toolbar buttons when editing a field inside a detail form."""),
    'lino.modlib.tinymce.Plugin.window_buttons1' : _("""The first row of toolbar buttons when editing in own window."""),
    'lino.modlib.tinymce.Plugin.window_buttons2' : _("""The second row of toolbar buttons when editing in own window."""),
    'lino.modlib.tinymce.Plugin.window_buttons3' : _("""The third row of toolbar buttons when editing in own window."""),
    'lino.modlib.tinymce.Plugin.media_name' : _("""Lino currently includes three versions of TinyMCE, but for
production sites we still use the eldest version 3.4.8."""),
    'lino.modlib.uploads.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.users.utils.UserTypeContext' : _("""A context manager which activates a current user type."""),
    'lino.modlib.weasyprint.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.wkhtmltopdf.Plugin' : _("""See /dev/plugins."""),
    'lino.sphinxcontrib.actordoc.CurrentLanguage' : _("""Tell Sphinx to switch to the specified language until the end of
this document."""),
    'lino.sphinxcontrib.actordoc.CurrentProject' : _("""Tell Sphinx to switch to the specified project until the end of
this document."""),
    'lino.sphinxcontrib.actordoc.Lino2rstDirective' : _("""Defines the lino2rst directive."""),
    'lino.utils.IncompleteDate' : _("""Naive representation of a potentially incomplete gregorian date."""),
    'lino.utils.IncompleteDate.parse' : _("""Parse the given string and return an IncompleteDate
object."""),
    'lino.utils.IncompleteDate.get_age' : _("""Return age in years as integer."""),
    'lino.utils.SumCollector' : _("""A dictionary of sums to be collected using an arbitrary key."""),
    'lino.utils.SumCollector.collect' : _("""This returns an empty string"""),
    'lino.utils.addressable.Addressable' : _("""General mixin (not only for Django models) to encapsulate the
generating of "traditional" ("snail") mail addresses."""),
    'lino.utils.addressable.Addressable.address' : _("""A property which calls get_address()."""),
    'lino.utils.addressable.Addressable.address_html' : _("""A property which calls get_address_html()."""),
    'lino.utils.addressable.Addressable.address_person_lines' : _("""Expected to yield one or more unicode strings, one for each line
of the person part."""),
    'lino.utils.addressable.Addressable.address_location_lines' : _("""Expected to yield one or more unicode strings, one for each line
of the location part."""),
    'lino.utils.addressable.Addressable.get_address_lines' : _("""Yields a series of strings, one for each line of the address."""),
    'lino.utils.addressable.Addressable.get_address' : _("""The plain text full postal address (person and location).  Lines
are separated by linesep which defaults to a newline."""),
    'lino.utils.addressable.Addressable.get_address_html' : _("""Returns the full postal address a a string containing html
markup of style:"""),
    'lino.utils.addressable.TestAddress' : _("""Used only for testing."""),
    'lino.utils.ajax.AjaxExceptionResponse' : _("""The middleware class definition."""),
    'lino.utils.choosers.Chooser' : _("""A chooser holds information about the possible choices of a
field."""),
    'lino.utils.choosers.Chooser.get_data_elem' : _("""Calls dd.Actor.get_data_elem() or
dd.Model.get_data_elem() or
dd.Action.get_data_elem()."""),
    'lino.utils.choosers.Chooser.get_choices' : _("""Return a list of choices for this chooser, using keyword parameters
as context."""),
    'lino.utils.choosers.Chooser.get_request_choices' : _("""Return a list of choices for this chooser,
using a HttpRequest to build the context."""),
    'lino.utils.code.SourceFile' : _("""Counts the number of code lines in a given Python source file."""),
    'lino.utils.config.ConfigDir' : _("""A directory that may contain configuration files."""),
    'lino.utils.daemoncommand.DaemonCommand' : _("""If you have an existing Django management command, just rename
it's handle method to handle_daemon and inherit from this
instead of django.core.management.base.BaseCommand."""),
    'lino.utils.daemoncommand.DaemonCommand.help' : _("""The loggers to preserve. If not None, this should be a list of
loggers (logging.Logger instances) whose file handles
should not get closed."""),
    'lino.utils.daemoncommand.DaemonCommand.execute' : _("""Takes the options and starts a daemon context from them."""),
    'lino.utils.dataserializer.FakeDeserializedObject' : _("""loaddata requires DeserializedObject instances, 
but this Deserializer does not bypass pre_save/save methods."""),
    'lino.utils.dates.DateRangeValue' : _("""A named tuple with the following fields:"""),
    'lino.utils.dates.DateRangeValue.start_date' : _("""The start date"""),
    'lino.utils.dates.DateRangeValue.end_date' : _("""The end date"""),
    'lino.utils.dbfreader.DBFFile' : _("""Represents a single DBF file."""),
    'lino.utils.dbfreader.DBFField' : _("""Represents a field in a DBF file."""),
    'lino.utils.dbfreader.FPTFile' : _("""Represents an FPT block file"""),
    'lino.utils.dbfreader.DBTFile' : _("""Represents a DBT block file"""),
    'lino.utils.diag.Analyzer' : _("""The class of the lino.utils.diag.analyzer object."""),
    'lino.utils.diag.Analyzer.show_window_fields' : _("""List all window actions and the form fields they contain."""),
    'lino.utils.diag.Analyzer.show_database_structure' : _("""Show a bullet list of all models and their fields."""),
    'lino.utils.diag.Analyzer.show_db_overview' : _("""Return a reStructredText-formatted "database overview" report.
Used by test cases in tested documents."""),
    'lino.utils.diag.Analyzer.show_foreign_keys' : _("""Return a list that shows how database objects are being referred to
by some other database object. This information is important
(1) before deleting objects and (2) when merging them."""),
    'lino.utils.djangotest.DjangoManageTestCase' : _("""Adds some extensions to the Django TestCase."""),
    'lino.utils.djangotest.DjangoManageTestCase.override_djangosite_settings' : _("""If specified, this is a dict of Site
attributes to override before running the test."""),
    'lino.utils.djangotest.DjangoManageTestCase.defining_module' : _("""When you decorate your subclass of TestCase, you must also specify:"""),
    'lino.utils.djangotest.DjangoManageTestCase.check_sql_queries' : _("""Checks whether the specified expected SQL queries match to those
who actually have been emitted."""),
    'lino.utils.djangotest.DjangoManageTestCase.client_json_dict' : _("""Send a POST or PUT to client with given username, url and data. The
client is expected to respond with a JSON encoded
response. Parse the response's content (which is expected to
contain a dict), convert this dict to an AttrDict before
returning it."""),
    'lino.utils.djangotest.DjangoManageTestCase.check_callback_dialog' : _("""Check wether the given dialog runs as expected and return the final
response as an AttrDict."""),
    'lino.utils.djangotest.RemoteAuthTestCase' : _("""Base class for tests that use remote http authentication.  We
override the __call__() method in order to simulate
remote_user_header <lino.core.site.Site.remote_user_header>
being set to 'REMOTE_USER'."""),
    'lino.utils.djangotest.TestCase' : _("""alias of lino.utils.djangotest.RemoteAuthTestCase"""),
    'lino.utils.djangotest.WebIndexTestCase' : _("""Designed to be just imported. No subclassing needed."""),
    'lino.utils.djangotest.RestoreTestCase' : _("""Used for testing migrations from previous versions."""),
    'lino.utils.djangotest.RestoreTestCase.tested_versions' : _("""A list of strings, each string is a version for which there must
be a migration dump created by makemigdump."""),
    'lino.utils.dpy.FakeDeserializedObject' : _("""Imitates DeserializedObject required by loaddata."""),
    'lino.utils.dpy.FakeDeserializedObject.try_save' : _("""Try to save the specified Model instance obj. Return True
on success, False if this instance wasn't saved and should be
deferred."""),
    'lino.utils.dpy.Serializer' : _("""Serializes a QuerySet to a py stream."""),
    'lino.utils.dpy.FlushDeferredObjects' : _("""Indicator class object.
Fixture may yield a FlushDeferredObjects
to indicate that all deferred objects should get saved before going on."""),
    'lino.utils.dpy.DpyLoader' : _("""Instantiated by restore.py."""),
    'lino.utils.dpy.DpyDeserializer' : _("""The Django deserializer for dpy."""),
    'lino.utils.dpy.Migrator' : _("""The SITE's Migrator class is instantiated by install_migrations."""),
    'lino.utils.dpy.Migrator.after_load' : _("""Declare a function to be called after all data has been loaded."""),
    'lino.utils.dpy.Migrator.before_load' : _("""Declare a function to be called before loading dumped data."""),
    'lino.utils.instantiator.LookupConverter' : _("""A Converter for ForeignKey and ManyToManyField. 
If the lookup_field is a BabelField, then it tries all available languages."""),
    'lino.utils.instantiator.ChoiceConverter' : _("""Converter for ChoiceListField."""),
    'lino.utils.instantiator.ForeignKeyConverter' : _("""Converter for ForeignKey fields."""),
    'lino.utils.instantiator.GenericForeignKeyConverter' : _("""Converter for GenericForeignKey fields."""),
    'lino.utils.instantiator.ManyToManyConverter' : _("""Converter for ManyToMany fields."""),
    'lino.utils.instantiator.Instantiator' : _("""A utility class to make python fixtures more compact. See
tutorial.instantiator."""),
    'lino.utils.instantiator.Instantiator.build' : _("""Instantiate an object using the default values of this
instantiator, overridden by the given specified values. The
number of positional arguments may not exceed the number of
fieldnames specified when creating this Instantiator."""),
    'lino.utils.instantiator.InstanceGenerator' : _("""Usage example see lino_xl.lib.humanlinks.fixtures."""),
    'lino.utils.jinja.Counter' : _("""Represents a counter. Usage see"""),
    'lino.utils.jsgen.js_code' : _("""A string that py2js will represent as is, not between quotes."""),
    'lino.utils.jsgen.Component' : _("""A Component is a Variable whose value is a dict of options.
Deserves more documentation."""),
    'lino.utils.jsgen.Component.walk' : _("""Walk over this component and its children."""),
    'lino.utils.jsgen.VisibleComponent' : _("""A visible component"""),
    'lino.utils.jsgen.VisibleComponent.install_permission_handler' : _("""Define the allow_read handler used by
get_view_permission().  This must be done only once, but
after having configured debug_permissions and
required_roles."""),
    'lino.utils.media.MediaFile' : _("""Represents a file on the server below MEDIA_ROOT with
two properties name and url."""),
    'lino.utils.media.MediaFile.name' : _("""return the filename on the server"""),
    'lino.utils.media.MediaFile.get_url' : _("""return the url that points to file on the server"""),
    'lino.utils.mldbc.fields.BabelCharField' : _("""Define a variable number of CharField database fields, one for
each language of your lino.core.site.Site.languages.  See
mldbc."""),
    'lino.utils.mldbc.fields.BabelTextField' : _("""Define a variable number of clones of the "master" field,
one for each language .
See mldbc."""),
    'lino.utils.mldbc.fields.LanguageField' : _("""A field that lets the user select a language from the available
lino.core.site.Site.languages."""),
    'lino.utils.mldbc.BabelNamed' : _("""Mixin for models that have a babel field name (labelled
"Designation" by default) for each language."""),
    'lino.utils.mldbc.BabelDesignated' : _("""Mixin for models that have a babel field "Designation" (i.e. one
designation for each language defined in the site's
languages."""),
    'lino.utils.mti.ChildCollector' : _("""A Collector that does not delete the MTI parents."""),
    'lino.utils.mti.EnableChild' : _("""Rendered as a checkbox that indicates whether an mti child of the
given model exists."""),
    'lino.utils.mti.EnableChild.is_enabled' : _("""When a FormLayout is inherited by an MTI child, EnableChild fields
must be disabled."""),
    'lino.utils.mti.EnableChild.has_child' : _("""Returns True if obj has an MTI child in self.child_model.  The
optional 2nd argument request (passed from
VirtualField.value_from_object) is ignored."""),
    'lino.utils.odsreader.SimpleOdsReader' : _("""Abstract base class. For each .ods file you are probably creating a
subclass of this."""),
    'lino.utils.odsreader.SimpleOdsReader.filename' : _("""The full path name of the .ods file to be read."""),
    'lino.utils.odsreader.SimpleOdsReader.headers' : _("""A list of unicode strings, one for each column in the file.  The
headers specified here must match exactly those found in the .ods
file."""),
    'lino.utils.odsreader.SimpleOdsReader.cells2row' : _("""This will be called for each recognized data row and may perform a
conversion before yielding it.  Subclasses may override this."""),
    'lino.utils.odsreader.SimpleOdsReader.rows' : _("""Yields the data rows found in this .ods file."""),
    'lino.utils.odsreader.OdsReader' : _("""Like SimpleOdsReader, but each row is converted to 
an lino.utils.AttrDict. This requires you to specifiy, 
besides the SimpleOdsReader.headers attrribute, 
another list of pure ASCII strings which must be valid Python 
attribute names."""),
    'lino.utils.pythontest.TestCase' : _("""An extended atelier.test.TestCase to be run using
setup.py in the root of a project which may contain
several Django projects."""),
    'lino.utils.pythontest.TestCase.django_settings_module' : _("""The DJANGO_SETTINGS_MODULE to set for each subprocess
launched by this test case."""),
    'lino.utils.pythontest.TestCase.run_django_manage_test' : _("""Run python manage.py test command in the given directory."""),
    'lino.utils.pythontest.TestCase.run_django_admin_test_cd' : _("""Run django-admin.py test in the given directory."""),
    'lino.utils.pythontest.TestCase.run_django_admin_command_cd' : _("""Run django-admin.py CMD in the given directory."""),
    'lino.utils.pythontest.TestCase.run_docs_doctests' : _("""Run a simple doctest for specified file after importing the docs
conf.py (which causes the demo database to be activated)."""),
    'lino.utils.report.EmptyTableRow' : _("""Base class for virtual rows of an EmptyTable.
An EmptyTableRow instance"""),
    'lino.utils.report.EmptyTableRow.get_print_templates' : _("""Overrides
lino.modlib.printing.mixins.Printable.get_print_templates()"""),
    'lino.utils.report.EmptyTable' : _("""A "Table" that has exactly one virtual row and thus is visible
only using a Detail view on that row."""),
    'lino.utils.report.EmptyTable.get_print_templates' : _("""Called from EmptyTableRow."""),
    'lino.utils.report.Report' : _("""A special kind of EmptyTable used to create "reports".  A report
is a series of headings, paragraphs and tables combined into a single
printable and previewable document."""),
    'lino.utils.report.Report.get_story' : _("""Yield a sequence of story items. Every item can be (1) an
ElementTree element or (2) a table or (3) an action request."""),
    'lino.utils.restify.HTMLTranslator' : _("""Suppress surrounding DIV tag. Used by restify()."""),
    'lino.utils.sendchanges.Emitter' : _("""The object returned by register()."""),
    'lino.utils.sendchanges.Emitter.register' : _("""Register this emitter."""),
    'lino.utils.sendchanges.Emitter.get_recipients' : _("""Return the list of recipients. Default is to return the global
list."""),
    'lino.utils.sendchanges.Emitter.emit_created' : _("""Send "created" mails for the given model instance obj."""),
    'lino.utils.sendchanges.Emitter.emit_updated' : _("""Send "updated" mails for the given ChangeWatcher cw."""),
    'lino.utils.sendchanges.Emitter.emit_deleted' : _("""Send "deleted" mails for the given model instance obj."""),
    'lino.utils.sqllog.SQLLogMiddleware' : _("""Log all SQL statements direct to the console."""),
    'lino.utils.sqllog.SQLLogToConsoleMiddleware' : _("""Log all SQL statements to the console.
Intended for use with the django development server."""),
    'lino.utils.sqllog.ShortSQLLogToConsoleMiddleware' : _("""Log a summary of the SQL statements made to the console.
Intended for use with the django development server."""),
    'lino.utils.test.HttpQuery.expected_rows' : _("""Alias for field number 3"""),
    'lino.utils.test.HttpQuery.json_fields' : _("""Alias for field number 2"""),
    'lino.utils.test.HttpQuery.kwargs' : _("""Alias for field number 4"""),
    'lino.utils.test.HttpQuery.url_base' : _("""Alias for field number 1"""),
    'lino.utils.test.HttpQuery.username' : _("""Alias for field number 0"""),
    'lino.utils.test.CommonTestCase' : _("""An extended django.test.TestCase."""),
    'lino.utils.test.CommonTestCase.create_obj' : _("""Create the given database object, run full_clean() and
save(), return the object."""),
    'lino.utils.test.CommonTestCase.check_json_result' : _("""Checks the result of response which is expected to return a
JSON-encoded dictionary with the expected_keys."""),
    'lino.utils.test.CommonTestCase.assertEquivalent' : _("""Compares two strings a (expected) and b (got), ignoring
whitespace repetitions and writing a logger message in case
they are different.  For long strings it's then more easy to
find the difference."""),
    'lino.utils.test.CommonTestCase.request_PUT' : _("""Sends a PUT request using Django's test client, overriding the
content_type keyword.  This is how ExtJS grids behave by
default."""),
    'lino.utils.test.DocTest' : _("""Looks for a file "index.rst" in your project_dir and (if it exists)
runs doctest on it."""),
    'lino.utils.test.DocTest.doctest_files' : _("""The files to be tested."""),
    'lino.utils.test.DemoTestCase' : _("""Used to define tests that are to be run directly in the demo
database, without using the Django test runner (i.e. without
creating a temporary test database)."""),
    'lino.utils.ucsv.UTF8Recoder' : _("""Iterator that reads an encoded stream and reencodes the input to UTF-8"""),
    'lino.utils.ucsv.UnicodeReader' : _("""A CSV reader which will iterate over lines in the CSV file "f",
which is encoded in the given encoding."""),
    'lino.utils.ucsv.UnicodeWriter' : _("""A CSV writer which will write rows to CSV file "f",
which is encoded in the given encoding."""),
    'lino.api.ad.Plugin' : _("""Shortcut to lino.core.plugins.Plugin."""),
    'lino.api.ad.Site' : _("""Shortcut to lino.core.site.Site."""),
    'lino.api.dd.Table' : _("""Shortcut to lino.core.dbtables.Table"""),
    'lino.api.dd.Choicelist' : _("""Shortcut to lino.core.choicelists.ChoiceList"""),
    'lino.api.dd.VirtualTable' : _("""Shortcut to lino.core.tables.VirtualTable"""),
    'lino.api.dd.VentilatingTable' : _("""Shortcut to lino.core.choicelists.ChoiceList"""),
    'lino.api.dd.Frame' : _("""Shortcut to lino.core.frames.Frame"""),
    'lino.modlib.about.About' : _("""A dialog window which displays some information about the site."""),
    'lino.modlib.about.TimeZones' : _("""The list of time zones available on this site."""),
    'lino.modlib.about.TimeZones.default' : _("""The default time zone on this server, corresponding to
TIME_ZONE.  Unlike TIME_ZONE (which is a
string), default is a choice object whose text
is the same as the string and which has an attribute
tzinfo which contains the time zone info object."""),
    'lino.modlib.contacts.Partner.client_contact_type' : _("""Setting this field on a partner makes this partner available
as a client contact."""),
    'lino.modlib.users.User.coaching_type' : _("""The coaching type used for new coachings of this user."""),
    'lino.modlib.users.User.coaching_supervisor' : _("""Notify me when a coach has been assigned."""),
    'lino.modlib.comments.Comment' : _("""A comment is a short text which some user writes about some database
object. It has no recipient."""),
    'lino.modlib.comments.Comment.body' : _("""The full body text of your comment."""),
    'lino.modlib.comments.Comment.short_preview' : _("""The first paragraph of your body."""),
    'lino.modlib.comments.Comment.user' : _("""The author of the comment."""),
    'lino.modlib.comments.Comment.owner' : _("""The topic this comment is about. This field is a Generic Foreign Key, i.e. users can
basically comment on any database object.  It is however the application
developer who decides where comments can be created and how they are being
displayed."""),
    'lino.modlib.comments.Comment.published' : _("""When this comment has been published. A timestamp."""),
    'lino.modlib.comments.Comments.show_published' : _("""Whether to show only (un)published comments, independently of
the publication date."""),
    'lino.modlib.comments.Comments.end_date' : _("""The date range to filter."""),
    'lino.modlib.comments.Comments.observed_event' : _("""Which event (created, modified or published) to consider when
applying the date range given by start_date and
end_date."""),
    'lino.modlib.comments.Comments.as_li' : _("""Return this comment for usage in a list item as a string with
HTML tags."""),
    'lino.modlib.comments.RecentComments.get_table_summary' : _("""The summary view for this table."""),
    'lino.modlib.comments.CommentsByRFC' : _("""Shows the comments for a given database object."""),
    'lino.modlib.comments.CommentsByRFC.get_table_summary' : _("""The summary view for this table."""),
    'lino.modlib.comments.CommentEvents' : _("""The choicelist with selections for
Comments.observed_event."""),
    'lino.modlib.comments.CommentType' : _("""The CommentType model is not being used in production,
one day we will probably remove it."""),
    'lino.modlib.comments.CommentTypes' : _("""The table with all existing comment types."""),
    'lino.modlib.comments.Commentable' : _("""Mixin for models that can be subject to comments."""),
    'lino.modlib.comments.Commentable.get_rfc_description' : _("""Return a HTML formatted string with the description of this
Commentable as it should be displayed by the slave summary of
CommentsByOwner."""),
    'lino.modlib.comments.Commentable.on_commented' : _("""This is automatically called when a comment has been created
or modified."""),
    'lino.modlib.comments.Commentable.get_comment_group' : _("""Return either None or a database object that represents the commenting group
where this comment is being done."""),
    'lino.modlib.files.Volume' : _("""The Django model representing a file volume."""),
    'lino.modlib.files.Volume.id' : _("""The primary key used to point to this volume from a database object."""),
    'lino.modlib.files.Volume.ref' : _("""The full path of the root folder."""),
    'lino.modlib.files.Volume.text' : _("""A descriptive text."""),
    'lino.modlib.files.Volume.base_url' : _("""The base URL where files of this volume are being served."""),
    'lino.modlib.files.Volume.backend' : _("""The file backend used to access the files on this volume."""),
    'lino.modlib.files.File.id' : _("""Internal ID to be used as primary key."""),
    'lino.modlib.files.File.volume' : _("""The volume where this file is stored."""),
    'lino.modlib.files.File.parent' : _("""The parent directory."""),
    'lino.modlib.files.File.is_folder' : _("""Whether this is a directory, i.e. a special file which contains other
files and has no content on its own."""),
    'lino.modlib.files.File.name' : _("""The name of this file.  Must be unique among siblings of a same parent."""),
    'lino.modlib.files.File.full_name' : _("""The full path name relative to the root folder of the volume."""),
    'lino.modlib.files.File.broken' : _("""Whether the file no longer exists on the file system."""),
    'lino.modlib.files.File.state' : _("""The state of this file, used to control the workflow."""),
    'lino.modlib.files.FileStates' : _("""A choicelist with the possible states of a file."""),
    'lino.modlib.files.Receivable' : _("""A mixin for models that require their every object to have a scan or pdf
file of the "receipt", i.e. the document serving as the legal proof of this
database object.  A usage example are purchase invoices in an accounting
system."""),
    'lino.modlib.files.Receivable.receipt' : _("""The file which serves as receipt for this database object."""),
    'lino.modlib.files.Receivable.needs_receipt' : _("""Return True if this database object needs a receipt."""),
    'lino.modlib.files.PendingReceivables' : _("""Shows all receivables that need a receipt but don't have any."""),
    'lino.modlib.files.BrokenFiles' : _("""Shows all unused files (i.e. which aren't referred to by any database
object)."""),
    'lino.modlib.files.DanglingReceipts' : _("""Shows all files that are a receipt but aren't used as such by any
receivable."""),
    'lino.modlib.gkfs.Controllable' : _("""Mixin for models that are "controllable" by another database object."""),
    'lino.modlib.gkfs.Controllable.update_controller_field' : _("""Update attributes of the owner field and its underlying
fields owner_id and owner_type."""),
    'lino.modlib.gkfs.Controllable.update_owned_instance' : _("""If this (acting as a controller) is itself controlled, forward the
call to the controller."""),
    'lino.modlib.gkfs.Controllable.owner_label' : _("""Deprecated. This is (and always was) being ignored. Use
update_controller_field() instead.
The labels (verbose_name) of the fields owned_type, owned_id
and owned are derived from this attribute which may be overridden by
subclasses."""),
    'lino.modlib.gkfs.ContentTypes' : _("""Lino installs this as the default table for
django.contrib.ContentType."""),
    'lino.modlib.gkfs.ContentTypes.base_classes' : _("""Display a clickable list of all MTI parents, i.e. base models"""),
    'lino.modlib.gkfs.HelpText' : _("""A custom help text to be displayed for a given field."""),
    'lino.modlib.gkfs.BrokenGFKs' : _("""Shows all database objects who have a broken GeneriForeignKey field."""),
    'lino.modlib.gkfs.GenericForeignKey' : _("""Add verbose_name and help_text to Django's GFK."""),
    'lino.modlib.gkfs.GenericForeignKeyIdField' : _("""Use this instead of models.PositiveIntegerField for fields that
are part of a GFK and you want Lino to render them using a
Combobox."""),
    'lino.modlib.memo.Previewable' : _("""Adds three rich text fields (lino.core.fields.RichTextField):"""),
    'lino.modlib.memo.Previewable.body' : _("""An editable text body."""),
    'lino.modlib.memo.Previewable.short_preview' : _("""A read-only short preview of body."""),
    'lino.modlib.memo.Previewable.full_preview' : _("""A read-only full preview of body."""),
    'lino.modlib.memo.PreviewableChecker' : _("""Check for previewables needing update."""),
    'lino.modlib.notify.Message' : _("""The Django model that represents a notification message."""),
    'lino.modlib.notify.Message.user' : _("""The recipient."""),
    'lino.modlib.notify.Message.owner' : _("""The database object which controls this message."""),
    'lino.modlib.notify.Message.emit_notification' : _("""Class method which creates one database object per recipient."""),
    'lino.modlib.notify.Message.create_message' : _("""Create a message unless that user has already been notified
about that object."""),
    'lino.modlib.notify.Message.send_summary_emails' : _("""Send summary emails for all pending notifications with the
given mail_mode mm."""),
    'lino.modlib.notify.Message.send_browser_message_for_all_users' : _("""Send_message to all connected users"""),
    'lino.modlib.notify.Message.send_browser_message' : _("""Send_message to the user's browser"""),
    'lino.modlib.notify.Messages' : _("""Base for all tables of messages."""),
    'lino.modlib.notify.AllMessages' : _("""The gobal list of all messages."""),
    'lino.modlib.notify.MyMessages' : _("""Shows messages emitted to me."""),
    'lino.modlib.notify.ChangeNotifier.get_change_subject' : _("""Returns the subject text of the notification message to emit."""),
    'lino.modlib.notify.ChangeNotifier.add_change_watcher' : _("""Parameters:"""),
    'lino.modlib.notify.ChangeNotifier.get_change_body' : _("""Returns the body text of the notification message to emit."""),
    'lino.modlib.notify.ChangeNotifier.get_change_info' : _("""This is called by get_change_body().
Subclasses can override this. Usage example
lino_xl.lib.notes.models.Note"""),
    'lino.modlib.notify.ChangeNotifier.get_change_owner' : _("""Return the owner of the notification to emit."""),
    'lino.modlib.notify.NotifyingAction' : _("""An action which pops up a dialog window of three fields "Summary",
"Description" and a checkbox "Don't notify others" to optionally
suppress notification."""),
    'lino.modlib.notify.NotifyingAction.get_notify_subject' : _("""Return the default value of the notify_subject field."""),
    'lino.modlib.notify.NotifyingAction.get_notify_body' : _("""Return the default value of the notify_body field."""),
    'lino.modlib.notify.NotifyingAction.get_notify_owner' : _("""Expected to return the owner
lino.modlib.notify.Message.owner> of the message."""),
    'lino.modlib.notify.NotifyingAction.get_notify_recipients' : _("""Yield a list of users to be notified."""),
    'lino.modlib.notify.MessageTypes' : _("""The list of possible choices for the message_type field
of a Message."""),
    'lino.modlib.notify.MailModes' : _("""How the system should send email notifications to a user."""),
    'lino.modlib.notify.MailModes.silent' : _("""Disable notifications for this user."""),
    'lino.modlib.notify.MailModes.never' : _("""Notify in Lino but never send email."""),
    'lino.modlib.notify.MarkSeen' : _("""Mark this message as seen."""),
    'lino.modlib.notify.MarkAllSeen' : _("""Mark all messages as seen."""),
    'lino.modlib.notify.ClearSeen' : _("""Mark this message as not yet seen."""),
    'lino.modlib.printing.Printable' : _("""Mixin for models for which Lino can generate a printable
document."""),
    'lino.modlib.printing.Printable.get_print_language' : _("""Return a Django language code to be activated when an instance
of this is being printed.  The default implementation returns
the Site's default language."""),
    'lino.modlib.printing.Printable.get_print_templates' : _("""Return a list of file names of templates for the specified
build method.  Returning an empty list means that this item is
not printable.  For subclasses of SimpleBuildMethod
the returned list may not contain more than 1 element."""),
    'lino.modlib.printing.Printable.get_printable_context' : _("""Adds a series of names to the context used when rendering
printable documents."""),
    'lino.modlib.printing.Printable.get_body_template' : _("""Return the name of the body template to use when rendering this
object in a printable excerpt (lino_xl.lib.excerpts).
An empty string means that Lino should use the default value
defined on the ExcerptType."""),
    'lino.modlib.printing.Printable.get_printable_demo_objects' : _("""Return an iterable of database objects for which Lino should
generate a printable excerpt."""),
    'lino.modlib.printing.Printable.get_build_method' : _("""Return the build method to use when printing this object."""),
    'lino.modlib.printing.Printable.get_excerpt_options' : _("""Set additional fields of newly created excerpts from this.  Called
from
lino_xl.lib.excerpts.models.ExcerptType.get_or_create_excerpt."""),
    'lino.modlib.printing.Printable.before_printable_build' : _("""This is called by print actions before the printable is being
generated.  Application code may e.g. raise a Warning
exception in order to refuse the print action.  The warning
message can be a translatable string."""),
    'lino.modlib.printing.CachedPrintable' : _("""Mixin for Models that generate a unique external file at a
determined place when being printed."""),
    'lino.modlib.printing.CachedPrintable.build_time' : _("""Timestamp of the built target file. Contains None
if no build hasn't been called yet."""),
    'lino.modlib.printing.CachedPrintable.do_print' : _("""The action used to print this object.
This is an instance of
DirectPrintAction or CachedPrintAction by
default.  And if lino_xl.lib.excerpts is installed,
then set_excerpts_actions possibly replaces
do_print by a
lino_xl.lib.excerpts.CreateExcerpt instance."""),
    'lino.modlib.printing.TypedPrintable' : _("""A CachedPrintable that uses a "Type" for deciding which
template to use on a given instance."""),
    'lino.modlib.printing.PrintableType' : _("""Base class for models that specify the
TypedPrintable.type."""),
    'lino.modlib.printing.PrintableType.templates_group' : _("""Default value for templates_group is the model's full name."""),
    'lino.modlib.printing.PrintableType.build_method' : _("""A pointer to an item of
lino.modlib.printing.choicelists.BuildMethods."""),
    'lino.modlib.printing.PrintableType.template' : _("""The name of the file to be used as template."""),
    'lino.modlib.printing.CachedPrintableChecker' : _("""Checks for missing cache files on all objects which inherit
CachedPrintable."""),
    'lino.modlib.printing.BasePrintAction' : _("""Base class for all "Print" actions."""),
    'lino.modlib.printing.DirectPrintAction' : _("""Print using a hard-coded template and without cache."""),
    'lino.modlib.printing.CachedPrintAction' : _("""A print action which uses a cache for the generated printable
document and builds is only when it doesn't yet exist."""),
    'lino.modlib.printing.ClearCacheAction' : _("""Defines the Clear cache button on a Printable record."""),
    'lino.modlib.printing.EditTemplate' : _("""Edit the print template, i.e. the file specified by
Printable.get_print_templates()."""),
    'lino.modlib.printing.BuildMethods' : _("""The choicelist of build methods offered on this site."""),
    'lino.modlib.printing.BuildMethod' : _("""Base class for all build methods.  A build method encapsulates the
process of generating a "printable document" that inserts data
from the database into a template, using a given combination of a
template parser and post-processor."""),
    'lino.modlib.printing.BuildMethod.use_webdav' : _("""Whether this build method results is an editable file.  For
example, .odt files are considered editable while .pdf files
aren't."""),
    'lino.modlib.printing.TemplatedBuildMethod' : _("""A BuildMethod which uses a template."""),
    'lino.modlib.printing.DjangoBuildMethod' : _("""A TemplatedBuildMethod which uses Django's templating engine."""),
    'lino.modlib.printing.XmlBuildMethod' : _("""Generates .xml files from .xml templates."""),
    'lino.modlib.printing.SimpleBuildMethod' : _("""Base for build methods which use Lino's templating system
(find_config_file)."""),
    'lino.modlib.printing.CustomBuildMethod' : _("""For example CourseToXls."""),
    'lino.modlib.printing.CustomBuildMethod.custom_build' : _("""Concrete subclasses must implement this."""),
    'lino.modlib.printing.LatexBuildMethod' : _("""Not actively used.
Generates .pdf files from .tex templates."""),
    'lino.modlib.printing.RtfBuildMethod' : _("""Not actively used.
Generates .rtf files from .rtf templates."""),
    'lino.modlib.printing.PisaBuildMethod' : _("""Deprecated.
Generates .pdf files from .html templates.
Requires pisa.
Usage example see lino_book.projects.pisa."""),
    'lino.modlib.about.SiteSearch' : _("""The virtual table used to implement site-wide searches"""),
    'lino.modlib.summaries.Summarized' : _("""Model mixin for database objects that have summary fields."""),
    'lino.modlib.summaries.Summarized.delete_them_all' : _("""Set this to True if all instances of this model should be considered
temporary data to be deleted by checksummaries."""),
    'lino.modlib.summaries.Summarized.compute_results' : _("""Action for updating all the summary fields on this database object."""),
    'lino.modlib.summaries.Summarized.reset_summary_data' : _("""Set all counters and sums to 0."""),
    'lino.modlib.summaries.Summarized.compute_summary_values' : _("""Reset summary data fields (reset_summary_data()), for
every collector (get_summary_collectors()) loop over its
database objects and collect data, then save this record."""),
    'lino.modlib.summaries.Summarized.update_for_filter' : _("""Runs compute_summary_values() on a a filtered queryset
based on keyword arguments."""),
    'lino.modlib.summaries.Summarized.get_summary_collectors' : _("""To be implemented by subclasses. This must yield a sequence
of (collector, qs) tuples, where collector is a callable
and qs a queryset. Lino will call collector for each obj
in qs. The collector is responsible for updating that
object."""),
    'lino.modlib.summaries.SlaveSummarized' : _("""Mixin for Summarized models that are related to a master."""),
    'lino.modlib.summaries.SlaveSummarized.master' : _("""The target model of the master will automatically receive an
action check_summaries."""),
    'lino.modlib.summaries.MonthlySummarized' : _("""A Summarized that will have more than one entries per master,
one for each month."""),
    'lino.modlib.summaries.MonthlySummarized.summary_period' : _("""Can be 'yearly' or 'monthly'."""),
    'lino.modlib.summaries.MonthlySlaveSummary' : _("""A combination of SlaveSummary and MonthlySummarized."""),
    'lino.modlib.summaries.CheckSummaries' : _("""Web UI version of checksummaries."""),
    'lino.modlib.summaries.UpdateSummariesByMaster' : _("""Update summary data for this object."""),
    'lino.modlib.tinymce.TextFieldTemplate' : _("""A reusable block of text that can be selected from a text editor to
be inserted into the text being edited."""),
    'lino.modlib.uploads.Upload' : _("""Django model representing an upload."""),
    'lino.modlib.uploads.Upload.type' : _("""The type of this upload."""),
    'lino.modlib.uploads.Upload.file' : _("""Pointer to the uploaded file. See
lino.mixins.uploadable.Uploadable.file"""),
    'lino.modlib.uploads.Upload.description' : _("""A short description entered manually by the user."""),
    'lino.modlib.uploads.Upload.description_link' : _("""Almost the same as description, but if file is
not empty, the text is clickable, and clicking on it opens the
uploaded file in a new browser window."""),
    'lino.modlib.uploads.AreaUploads' : _("""Mixin for tables of uploads where the area is known. Inherited by
UploadsByController."""),
    'lino.modlib.uploads.MyUploads' : _("""Shows my uploads (i.e. those whose author is the current user)."""),
    'lino.modlib.uploads.UploadsByController' : _("""Shows the uploads controlled by this database object."""),
    'lino.modlib.uploads.UploadType' : _("""The type of an upload."""),
    'lino.modlib.uploads.UploadType.shortcut' : _("""Optional pointer to a virtual upload shortcut field.  If
this is not empty, then the given shortcut field will manage
uploads of this type.  See also Shortcuts."""),
    'lino.modlib.uploads.UploadTypes' : _("""The table with all existing upload types."""),
    'lino.modlib.uploads.UploadController.show_uploads' : _("""Show uploads in a grid table."""),
    'lino.modlib.uploads.Shortcuts' : _("""The list of upload shortcut fields which have been declared on this
Site."""),
    'lino.modlib.users.User' : _("""Fields:"""),
    'lino.modlib.users.User.authenticated' : _("""This is always True.  Compare with
AnonymousUser.authenticated."""),
    'lino.modlib.users.User.username' : _("""Must be unique and cannot be empty."""),
    'lino.modlib.users.User.initials' : _("""The nickname or initials of this user. This does not need to
be unique but should provide a reasonably identifying
function."""),
    'lino.modlib.users.User.user_type' : _("""The user_type of a user is what defines her or his permissions."""),
    'lino.modlib.users.User.partner' : _("""Pointer to the Partner instance related to
this user."""),
    'lino.modlib.users.User.person' : _("""A virtual read-only field which returns the Person MTI child of the
partner (if it exists) and otherwise None."""),
    'lino.modlib.users.User.last_login' : _("""Not used in Lino."""),
    'lino.modlib.users.User.__str__' : _("""Returns either the initials or get_full_name()."""),
    'lino.modlib.users.User.get_full_name' : _("""Return the first_name plus the last_name, with a space in
between. If both fields are empty, return the initials
or the username."""),
    'lino.modlib.users.User.start_date' : _("""The site administrator can optionally specify a date when a
user started or stopped to be active."""),
    'lino.modlib.users.Authority' : _("""An authority is when a user gives another user the right to
"represent" them."""),
    'lino.modlib.users.Authority.user' : _("""The user who gives the right of representation. author of this
authority"""),
    'lino.modlib.users.Authority.authorized' : _("""The user who gets the right to represent the author"""),
    'lino.modlib.users.Users' : _("""Base class for all user tables."""),
    'lino.modlib.users.AllUsers' : _("""Shows the list of all users on this site."""),
    'lino.modlib.users.UsersOverview' : _("""A variant of Users showing only active users and only some
fields.  This is used on demo sites in admin_main.html to
display the list of available users."""),
    'lino.modlib.users.UserTypes' : _("""The list of user types available in this application."""),
    'lino.modlib.users.UserType' : _("""Base class for all user types."""),
    'lino.modlib.users.UserType.role' : _("""The role of users having this type. This is an instance of
<lino.core.roles.UserRole> or some subclass thereof."""),
    'lino.modlib.users.UserType.readonly' : _("""Whether users of this type get only write-proteced access."""),
    'lino.modlib.users.UserType.hidden_languages' : _("""A subset of languages
which should be hidden for users of this type.  Default value
is hidden_languages.  This
is used on multilingual sites with more than 4 or 5 languages."""),
    'lino.modlib.users.UserType.context' : _("""Return a context manager so you can write code to be run with
this as the current user type:"""),
    'lino.modlib.users.Plugin' : _("""See /dev/plugins."""),
    'lino.modlib.users.Plugin.online_registration' : _("""Whether this site offers online registration of new users."""),
    'lino.modlib.users.Helper' : _("""Somebody who can help others by running AssignToMe
action."""),
    'lino.modlib.users.AuthorshipTaker' : _("""Somebody who can help others by running TakeAuthorship
action."""),
    'lino.modlib.users.SendWelcomeMail' : _("""Send a welcome mail to this user."""),
    'lino.modlib.users.ChangePassword' : _("""Change the password of this user."""),
    'lino.modlib.users.ChangePassword.current' : _("""The current password. Leave empty if the user has no password
yet. And SiteAdmin users don't need to specify this at all."""),
    'lino.modlib.users.ChangePassword.new1' : _("""The new password."""),
    'lino.modlib.users.ChangePassword.new2' : _("""The new password a second time. Both passwords must match."""),
    'lino.modlib.users.SignIn' : _("""Open a window which asks for username and password and which
authenticates as this user when submitted."""),
    'lino.modlib.users.SignOut' : _("""Sign out the current user and return to the welcome screen for
anonymous visitors."""),
    'lino.modlib.users.Authored.manager_roles_required' : _("""The list of required roles for getting permission to edit
other users' work."""),
    'lino.modlib.users.Authored.author_field_name' : _("""No longer used. The name of the field that defines the author
of this object."""),
    'lino.modlib.users.UserAuthored' : _("""Inherits from Authored."""),
    'lino.modlib.users.UserAuthored.user' : _("""The author of this object.
A pointer to lino.modlib.users.models.User."""),
    'lino.modlib.users.StartPlan.update_after_start' : _("""Whether to run Plan.update_plan() after starting the plan."""),
    'lino.modlib.users.UserPlan' : _("""Mixin for anything that represents a "plan" of a given user on a given day."""),
    'lino.modlib.users.UserPlan.user' : _("""The user who owns and uses this plan."""),
    'lino.modlib.users.UserPlan.today' : _("""This date of this plan.  This is automatically set to today
each time the plan is called or updated."""),
    'lino.modlib.users.UserPlan.run_start_plan' : _("""Return the database object for this plan and user.
or create"""),
    'lino.modlib.users.UserPlan.update_plan' : _("""Implementing models should provide this method."""),
    'lino.modlib.users.UpdatePlan' : _("""Build a new list of suggestions.
This will remove all current suggestions."""),
    'lino.modlib.weasyprint.WeasyBuildMethod' : _("""The base class for both build methods."""),
    'lino.modlib.weasyprint.WeasyHtmlBuildMethod' : _("""Renders the input template and returns the unmodified output as
plain HTML."""),
    'lino.modlib.weasyprint.WeasyPdfBuildMethod' : _("""Like WeasyBuildMethod, but the rendered HTML is then
passed through weasyprint which converts from HTML to PDF."""),
}
