zi<|dZddlmZddlZddlmZmZddlmZm Z m Z m Z m Z m Z ddlmZmZmZddlmZddlmZer8dd lmZmZdd lmZdd lmZdd lmZdd lm Z ddl!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(GddZ)Gdde Z*GddeZ+e ege e,fZ-GddZ.dS)zSupport for domains. Domains are groupings of description directives and roles describing e.g. constructs of one programming language. ) annotationsN)ABCabstractmethod) TYPE_CHECKINGAnyCallable NamedTupleOptionalcast)ElementNodesystem_message) SphinxError)_)IterableSequence)nodes) Directive)Inliner) pending_xref)Builder)BuildEnvironment)XRefRole) RoleFunctionc"eZdZdZddiZd d Zd S)ObjTypea3 An ObjType is the description for a type of object that a domain can document. In the object_types attribute of Domain subclasses, object type names are mapped to instances of this class. Constructor arguments: - *lname*: localized name of the type (do not include domain name) - *roles*: all the roles that can refer to an object of this type - *attrs*: object attributes -- currently only "searchprio" is known, which defines the object's priority in the full-text search index, see :meth:`Domain.get_objects()`. searchpriolnamestrrolesrattrsreturnNonec||_||_|j|_|j|dSN)rr! known_attrscopyr"update)selfrr!r"s b/var/www/tmov.alphamb/tmov_inventario/venv/lib/python3.11/site-packages/sphinx/domains/__init__.py__init__zObjType.__init__3sB ! +0022  %     N)rr r!rr"rr#r$)__name__ __module__ __qualname____doc__r'r,r-r+rr s@   aK!!!!!!r-rcVeZdZUded<ded<ded<ded<ded<ded<ded <d S) IndexEntryr nameintsubtypedocnameanchorextra qualifierdescrN)r.r/r0__annotations__r2r-r+r4r4:sO IIILLLLLLKKKJJJNNNJJJJJr-r4cXeZdZUdZded<ded<dZded<dd ZedddZdS)Indexa An Index is the description for a domain-specific index. To add an index to a domain, subclass Index, overriding the three name attributes: * `name` is an identifier used for generating file names. It is also used for a hyperlink target for the index. Therefore, users can refer the index page using ``ref`` role and a string which is combined domain name and ``name`` attribute (ex. ``:ref:`py-modindex```). * `localname` is the section title for the index. * `shortname` is a short name for the index, for use in the relation bar in HTML output. Can be empty to disable entries in the relation bar. and providing a :meth:`generate()` method. Then, add the index class to your domain's `indices` list. Extensions can add indices to existing domains using :meth:`~sphinx.application.Sphinx.add_index_to_domain()`. .. versionchanged:: 3.0 Index pages can be referred by domain name and index name via :rst:role:`ref` role. r r5 localnameN str | None shortnamedomainDomainr#r$ch|j|jtd|jjz||_dS)Nz0Index subclass %s has no valid name or localname)r5r@r __class__r.rC)r*rCs r+r,zIndex.__init___s> 9  6P $ 7899 9 r-docnamesIterable[str] | None/tuple[list[tuple[str, list[IndexEntry]]], bool]ct)aGet entries for the index. If ``docnames`` is given, restrict to entries referring to these docnames. The return value is a tuple of ``(content, collapse)``: ``collapse`` A boolean that determines if sub-entries should start collapsed (for output formats that support collapsing sub-entries). ``content``: A sequence of ``(letter, entries)`` tuples, where ``letter`` is the "heading" for the given ``entries``, usually the starting letter, and ``entries`` is a sequence of single entries. Each entry is a sequence ``[name, subtype, docname, anchor, extra, qualifier, descr]``. The items in this sequence have the following meaning: ``name`` The name of the index entry to be displayed. ``subtype`` The sub-entry related type. One of: ``0`` A normal entry. ``1`` An entry with sub-entries. ``2`` A sub-entry. ``docname`` *docname* where the entry is located. ``anchor`` Anchor for the entry within ``docname`` ``extra`` Extra info for the entry. ``qualifier`` Qualifier for the description. ``descr`` Description for the entry. Qualifier and description are not rendered for some output formats such as LaTeX. NotImplementedError)r*rGs r+generatezIndex.generatees h"!r-)rCrDr#r$r&)rGrHr#rI) r.r/r0r1r=rBr,rrMr2r-r+r?r?Ds~,IIINNN I     3"3"3"3"^3"3"3"r-r?ceZdZUdZdZdZiZded<iZded<iZ ded<gZ d ed <iZ d ed <iZ d ed<iZ ded<ded<dZdGdZdHdZdIdZdJdZdKd!ZdLd#ZdMd'ZdNd*ZdHd+ZdOd.ZdPd8ZdQd:ZdRd<ZdSdTdAZdUdDZdVdEZdFS)WrDa 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. zdict[str, ObjType] object_typeszdict[str, type[Directive]] directivesz"dict[str, RoleFunction | XRefRole]r!zlist[type[Index]]indiceszdict[str, str]dangling_warningsz0dict[type[Node], tuple[str, TitleGetter | None]]enumerable_nodesdict initial_datadatarenvrr#r$c||_i|_i|_i|_i|_t |j|_t |j|_t |j|_t|j |_ |j |j vrVt|jt sJtj|j}|j|d<|x|_|j |j <nD|j |j |_|jd|jkrt'd|jz|jD][\}}|jD]0}|j|g|1|jr |jdnd|j|<\|jj|_|jj|_dS)Nversionzdata of %r domain out of daterrO)rX _role_cache_directive_cache _role2type _type2rolerUrPrQr!listrRr5 domaindata isinstancerVr(deepcopy data_versionrWOSErrorlabelitems setdefaultappendgetobjtypes_for_rolerole_for_objtype)r*rXnew_datar5objrolenames r+r,zDomain.__init__s%(025702*,!!233t//$*%% DL)) 9CN * *d/66 6 6 6}T%677H"&"3HY 4< }|jr5|jr.|jd|j}|||d|j?dS)zSet up domain object.r)StandardDomainstd-rON) sphinx.domains.stdrpr rX get_domainrRr5r@note_hyperlink_target)r*rprqindexr8s r+setupz Domain.setups555555>48#6#6u#=#=>>\ Q QEz Qeo Q!Y5555))'7BPPP Q Qr-r5r objtyperc||j|<|jr|jd|j|<n d|j|<|jD]0}|j|g|1dS)zAdd an object type.rrON)rPr!r^r]rgrh)r*r5rxroles r+add_object_typezDomain.add_object_types")$ = '$+M!$4DOD ! !$&DOD !M > >D O & &tR 0 0 7 7 = = = = > >r-RoleFunction | Nonecjvr jSjvrdSjd ddfd }|j<|S)zReturn a role adapter function that always gives the registered role its full name ('domain:name') as the first argument. N:r2typr rawtexttextlinenor6inlinerroptions dict | Nonecontent Sequence[str]r#'tuple[list[Node], list[system_message]]c @ j|||||pi|Sr&)r!) rrrrrrrfullnamer5r*s r+ role_adapterz!Domain.role..role_adapter s6$4:d#HgtV$+W]GEE Er-)Nr2)rr rr rr rr6rrrrrrr#r)r[r!r5)r*r5rrs`` @r+rzz Domain.roles 4# # ##D) ) tz ! !4i(($((CG24 E E E E E E E E E ".r-Callable | Nonec||jvr |j|S||jvrdS|jd||j|}Gfdd|}||j|<|S)zReturn a directive adapter class that always gives the registered directive its full name ('domain:name') as ``self.name``. Nr~c$eZdZdfd ZxZS)*Domain.directive..DirectiveAdapterr# list[Node]cR|_tSr&)r5superrun)r*rFrs r+rz.Domain.directive..DirectiveAdapter.runs$ ww{{}}$r-)r#r)r.r/r0r __classcell__)rFrs@r+DirectiveAdapterrsC % % % % % % % % % % %r-r)r\rQr5)r*r5 BaseDirectiverrs @r+ directivezDomain.directives 4( ( ((. . t & &4i(($((-  % % % % % % %} % % %'7d#r-r8cdS)z?Remove traces of a document in the domain-specific inventories.Nr2)r*r8s r+ clear_doczDomain.clear_doc' r-rG list[str] otherdatac0td|jz)zMerge in data regarding *docnames* from a different domaindata inventory (coming from a subprocess in parallel builds). zLmerge_domaindata must be implemented in %s to be able to do parallel builds!)rLrF)r*rGrs r+merge_domaindatazDomain.merge_domaindata+s&"#F"&.#122 2r-documentnodes.documentcdS)z7Process a document after it is read by the environment.Nr2)r*rXr8rs r+ process_doczDomain.process_doc3s  r-cdS)z)Do consistency checks (**experimental**).Nr2r*s r+check_consistencyzDomain.check_consistency8rr-pnodercdS)zxProcess a pending xref created in a doc field. For example, attach information about the current scope. Nr2)r*rs r+process_field_xrefzDomain.process_field_xref<s  r- fromdocnamebuilderrrtargetnodecontnoder Element | NonecdS)aLResolve 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. Nr2)r*rXrrrrrrs r+ resolve_xrefzDomain.resolve_xrefBs r-list[tuple[str, Element]]ct)a9Resolve 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 rK)r*rXrrrrrs r+resolve_any_xrefzDomain.resolve_any_xrefTs "!r--Iterable[tuple[str, str, str, str, str, int]]cgS)auReturn 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. r2rs r+ get_objectszDomain.get_objectsfs B r-FtypeprimaryboolcP|r|jStd|j|jfzS)z#Return full name for given ObjType.z%s %s)rrre)r*rrs r+ get_type_namezDomain.get_type_names,  : zzTZ444r-r rAcL|j|jd\}}|S)z,Get type of enumerable nodes (experimental).)NN)rTrirF)r*renum_node_typers r+get_enumerable_node_typezDomain.get_enumerable_node_types' 155dnlSSr-cdS)z*Return full qualified name for given node.Nr2)r*rs r+get_full_qualified_namezDomain.get_full_qualified_namerr-N)rXrr#r$)r#r$)r5r rxrr#r$)r5r r#r|)r5r r#r)r8r r#r$)rGrrrUr#r$)rXrr8r rrr#r$)rrr#r$)rXrrr rrrr rr rrrr r#r)rXrrr rrrr rrrr r#r)r#r)F)rrrrr#r )rr r#rA)rr r#rA)r.r/r0r1r5rerPr=rQr!rRrSrTrVrcr,rwr{rzrrrrrrrrrrrrr2r-r+rDrDs. D E')L))))-/J////02E2222!#G####(*****IKKKKKLJJJL4444: Q Q Q Q > > > >&    (    2222                $""""$!!!!F55555        r-rD)/r1 __future__rr(abcrrtypingrrrr r r docutils.nodesr r r sphinx.errorsr sphinx.localercollections.abcrrdocutilsrdocutils.parsers.rstrdocutils.parsers.rst.statesrsphinx.addnodesrsphinx.buildersrsphinx.environmentr sphinx.rolesrsphinx.util.typingrrr4r?r TitleGetterrDr2r-r+rs> #""""" ########KKKKKKKKKKKKKKKK8888888888%%%%%% 022222222......333333,,,,,,''''''333333%%%%%%//////!!!!!!!!4U"U"U"U"U"CU"U"U"pvx},- w w w w w w w w w w r-