class documentation

A Domain is meant to be a group of "object" description directives for objects of a similar nature, and corresponding roles to create references to them. Examples would be Python modules, classes, functions etc., elements of a templating language, Sphinx roles and directives, etc. Each domain has a separate storage for information about existing objects and how to reference them in `self.data`, which must be a dictionary. It also must implement several functions that expose the object information in a uniform way to parts of Sphinx that allow the user to reference or search for objects in a domain-agnostic way. About `self.data`: since all object and cross-referencing information is stored on a BuildEnvironment instance, the `domain.data` object is also stored in the `env.domaindata` dict under the key `domain.name`. Before the build process starts, every active domain is instantiated and given the environment object; the `domaindata` dict must then either be nonexistent or a dictionary whose 'version' key is equal to the domain class' :attr:`data_version` attribute. Otherwise, `OSError` is raised and the pickled environment is discarded.

Method __init__ Undocumented
Method add_object_type Add an object type.
Method check_consistency Do consistency checks (**experimental**).
Method clear_doc Remove traces of a document in the domain-specific inventories.
Method directive Return a directive adapter class that always gives the registered directive its full name ('domain:name') as ``self.name``.
Method get_enumerable_node_type Get type of enumerable nodes (experimental).
Method get_full_qualified_name Return full qualified name for given node.
Method get_objects Return an iterable of "object descriptions".
Method get_type_name Return full name for given ObjType.
Method merge_domaindata Merge in data regarding *docnames* from a different domaindata inventory (coming from a subprocess in parallel builds).
Method process_doc Process a document after it is read by the environment.
Method process_field_xref Process a pending xref created in a doc field. For example, attach information about the current scope.
Method resolve_any_xref Resolve the pending_xref *node* with the given *target*.
Method resolve_xref Resolve the pending_xref *node* with the given *typ* and *target*.
Method role Return a role adapter function that always gives the registered role its full name ('domain:name') as the first argument.
Method setup Set up domain object.
Class Variable dangling_warnings Undocumented
Class Variable data_version Undocumented
Class Variable enumerable_nodes Undocumented
Class Variable initial_data Undocumented
Class Variable label Undocumented
Class Variable name Undocumented
Instance Variable data Undocumented
Instance Variable directives Undocumented
Instance Variable env Undocumented
Instance Variable indices Undocumented
Instance Variable object_types Undocumented
Instance Variable objtypes_for_role Undocumented
Instance Variable role_for_objtype Undocumented
Instance Variable roles Undocumented
Instance Variable _directive_cache Undocumented
Instance Variable _role2type Undocumented
Instance Variable _role_cache Undocumented
Instance Variable _type2role Undocumented
def __init__(self, env): (source)

Undocumented

Parameters
env:BuildEnvironmentUndocumented
def add_object_type(self, name, objtype): (source)

Add an object type.

Parameters
name:strUndocumented
objtype:ObjTypeUndocumented
def check_consistency(self): (source)

Do consistency checks (**experimental**).

def directive(self, name): (source)

Return a directive adapter class that always gives the registered directive its full name ('domain:name') as ``self.name``.

Parameters
name:strUndocumented
Returns
Callable|NoneUndocumented
def get_enumerable_node_type(self, node): (source)

Get type of enumerable nodes (experimental).

Parameters
node:NodeUndocumented
Returns
str|NoneUndocumented
def get_full_qualified_name(self, node): (source)

Return full qualified name for given node.

Parameters
node:ElementUndocumented
Returns
str|NoneUndocumented
def get_objects(self): (source)

Return an iterable of "object descriptions". Object descriptions are tuples with six items: ``name`` Fully qualified name. ``dispname`` Name to display when searching/linking. ``type`` Object type, a key in ``self.object_types``. ``docname`` The document where it is to be found. ``anchor`` The anchor name for the object. ``priority`` How "important" the object is (determines placement in search results). One of: ``1`` Default priority (placed before full-text matches). ``0`` Object is important (placed before default-priority objects). ``2`` Object is unimportant (placed after full-text matches). ``-1`` Object should not show up in search at all.

Returns
Iterable[tuple[str, str, str, str, str, int]]Undocumented
def get_type_name(self, type, primary=False): (source)

Return full name for given ObjType.

Parameters
type:ObjTypeUndocumented
primary:boolUndocumented
Returns
strUndocumented
def process_doc(self, env, docname, document): (source)
def process_field_xref(self, pnode): (source)

Process a pending xref created in a doc field. For example, attach information about the current scope.

Parameters
pnode:pending_xrefUndocumented
def resolve_any_xref(self, env, fromdocname, builder, target, node, contnode): (source)

Resolve the pending_xref *node* with the given *target*. The reference comes from an "any" or similar role, which means that we don't know the type. Otherwise, the arguments are the same as for :meth:`resolve_xref`. The method must return a list (potentially empty) of tuples ``('domain:role', newnode)``, where ``'domain:role'`` is the name of a role that could have created the same reference, e.g. ``'py:func'``. ``newnode`` is what :meth:`resolve_xref` would return. .. versionadded:: 1.3

Parameters
env:BuildEnvironmentUndocumented
fromdocname:strUndocumented
builder:BuilderUndocumented
target:strUndocumented
node:pending_xrefUndocumented
contnode:ElementUndocumented
Returns
list[tuple[str, Element]]Undocumented
def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): (source)

Resolve the pending_xref *node* with the given *typ* and *target*. This method should return a new node, to replace the xref node, containing the *contnode* which is the markup content of the cross-reference. If no resolution can be found, None can be returned; the xref node will then given to the :event:`missing-reference` event, and if that yields no resolution, replaced by *contnode*. The method can also raise :exc:`sphinx.environment.NoUri` to suppress the :event:`missing-reference` event being emitted.

Parameters
env:BuildEnvironmentUndocumented
fromdocname:strUndocumented
builder:BuilderUndocumented
typ:strUndocumented
target:strUndocumented
node:pending_xrefUndocumented
contnode:ElementUndocumented
Returns
Element|NoneUndocumented
def role(self, name): (source)

Return a role adapter function that always gives the registered role its full name ('domain:name') as the first argument.

Parameters
name:strUndocumented
Returns
RoleFunction|NoneUndocumented
def setup(self): (source)

Set up domain object.

data_version: int = (source)

Undocumented

Undocumented

Undocumented

objtypes_for_role: Callable[[str], list[str]] = (source)

Undocumented

role_for_objtype: Callable[[str], str] = (source)

Undocumented

_directive_cache: dict[str, Callable] = (source)

Undocumented

_role2type: dict[str, list[str]] = (source)

Undocumented

Undocumented

_type2role: dict[str, str] = (source)

Undocumented