o 7hnu@sdZddlmZddlZddlmZmZmZmZm Z m Z m Z ddl m Zddl mZddlmZmZddlmZmZmZdd lmZmZdd lmZdd lmZdd lm Z erxdd l!m"Z"ddlm#Z#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*GdddZ+Gddde+Z,GdddZ-Gddde+Z.Gddde.Z/GdddZ0GdddZ1Gd d!d!e e2d"fZ3Gd#d"d"Z4dS)$zFundamental Open Packaging Convention (OPC) objects. The :mod:`pptx.packaging` module coheres around the concerns of reading and writing presentations to and from a .pptx file. ) annotationsN)IO TYPE_CHECKING DefaultDictIteratorMappingSetcast)RELATIONSHIP_TARGET_MODE)RELATIONSHIP_TYPE)CT_Relationshipsserialize_part_xml)CONTENT_TYPES_URI PACKAGE_URIPackURI) PackageReader PackageWriter)CaseInsensitiveDict) parse_xml) lazyproperty)Self)CT_RelationshipCT_Types)BaseOxmlElement)Package)PresentationPartc@sHeZdZdZdddZddd dZdddZdddZedddZ dS)_RelatableMixinzHProvide relationship methods required by both the package and each part.reltypestrreturnPartcC |j|S)zReturn (single) part having relationship to this package of `reltype`. Raises |KeyError| if no such relationship is found and |ValueError| if more than one such relationship is found. )_relspart_with_reltype)selfrr%X/var/www/html/figdemos/bartoux_crm/venv/lib/python3.10/site-packages/pptx/opc/package.pypart_related_by!s z_RelatableMixin.part_related_byFtarget Part | str is_externalboolcCs.t|tr|s J|j||S|j||S)zReturn rId key of relationship of `reltype` to `target`. If such a relationship already exists, its rId is returned. Otherwise the relationship is added and its new rId returned. ) isinstancerr"get_or_add_ext_rel get_or_add)r$r(rr*r%r%r& relate_to)s z_RelatableMixin.relate_torIdcC |j|jS)z2Return related |Part| subtype identified by `rId`.)r" target_partr$r0r%r%r& related_part5 z_RelatableMixin.related_partcCr1)zGReturn URL contained in target ref of relationship identified by `rId`.)r" target_refr3r%r%r&r69r5z_RelatableMixin.target_ref_RelationshipscCstdt|j)zJ|_Relationships| object containing relationships from this part to others.z`%s` must implement `.rels`)NotImplementedErrortype__name__r$r%r%r&r"=s z_RelatableMixin._relsNrrrr F)r(r)rrr*r+rr)r0rrr )r0rrrrr7) r: __module__ __qualname____doc__r'r/r4r6rr"r%r%r%r&rs   rc@seZdZdZd$ddZed%dd Zd&d dZd'ddZd(ddZ e d)ddZ d*ddZ d+ddZ d,ddZed-d!d"Zd#S). OpcPackagezMain API class for |python-opc|. A new instance is constructed by calling the :meth:`open` classmethod with a path to a package file or file-like object containing a package (.pptx file). pkg_filestr | IO[bytes]cC ||_dSN) _pkg_filer$rCr%r%r&__init__L zOpcPackage.__init__rrcCs ||S)zGReturn an |OpcPackage| instance loaded with the contents of `pkg_file`._load)clsrCr%r%r&openO zOpcPackage.openr0rNonecCs|j|dS)z(Remove relationship identified by `rId`.Nr"popr3r%r%r&drop_relTszOpcPackage.drop_relIterator[Part]ccsBt}|D]}|jrq|j}||vrq|V||qdS)z;Generate exactly one reference to each part in the package.N)set iter_relsr*r2add)r$visitedrelpartr%r%r& iter_partsXs  zOpcPackage.iter_partsIterator[_Relationship]c#s,tdfdd |jEdHdS) zGenerate exactly one reference to each relationship in package. Performs a depth-first traversal of the rels graph. relsr7rr\c3sL|D]}|V|jrq|j}|vrq||jEdHqdSrF)valuesr*r2rWr])r]rYrZrX walk_relsr%r&r`ks  z'OpcPackage.iter_rels..walk_relsN)r]r7rr\)rUr"r;r%r_r&rVdszOpcPackage.iter_relsrcCstd|tjS)zReturn |Part| subtype serving as the main document part for this package. In this case it will be a |Presentation| part. r)r r'RTOFFICE_DOCUMENTr;r%r%r&main_document_part}szOpcPackage.main_document_parttmplrcsj|d|ddfdd|D}tt|dddD]}||}||vr0t|Sq td ) aReturn |PackURI| next available partname matching `tmpl`. `tmpl` is a printf (%)-style template string containing a single replacement item, a '%d' to be used to insert the integer portion of the partname. Example: '/ppt/slides/slide%d.xml' N*42csh|] }|jr|jqSr%)partname startswith.0pprefixr%r& sz+OpcPackage.next_partname..rz0ProgrammingError: ran out of candidate_partnames)findr[rangelenr Exception)r$rdZ partnamesnZcandidate_partnamer%rlr& next_partnames  zOpcPackage.next_partnamecCst||jt|dS)zzSave this package to `pkg_file`. `file` can be either a path to a file (a string) or a file-like object. N)rwriter"tupler[rHr%r%r&saveszOpcPackage.savecCs,t|jtd|\}}|jt|||S)z=Return the package after loading all parts and relationships.r)_PackageLoaderloadrGr r" load_from_xmlr)r$Z pkg_xml_relspartsr%r%r&rLszOpcPackage._loadr7cCs ttjS)z@|Relationships| object containing relationships of this package.)r7rbaseURIr;r%r%r&r" zOpcPackage._relsN)rCrD)rCrDrrr0rrrP)rrT)rr\)rr)rdrrr)rCrDrrP)rrr>)r:r?r@rArI classmethodrNrSr[rVpropertyrcrvryrLrr"r%r%r%r&rBEs         rBc@steZdZdZd ddZed!d d Zd"d d Zed#ddZ ed$ddZ ed%ddZ ed&ddZ d'ddZ dS)(rzz@Function-object that loads a package from disk (or other store).rCrDpackagercC||_||_dSrF)rG_package)r$rCrr%r%r&rI z_PackageLoader.__init__r,tuple[CT_Relationships, dict[PackURI, Part]]cCs|||S)a Return (pkg_xml_rels, parts) pair resulting from loading `pkg_file`. The returned `parts` value is a {partname: part} mapping with each part in the package included and constructed complete with its relationships to other parts in the package. The returned `pkg_xml_rels` value is a `CT_Relationships` object containing the parsed package relationships. It is the caller's responsibility (the package object) to load those relationships into its |_Relationships| object. rK)rMrCrr%r%r&r{s z_PackageLoader.loadcCs<|j|j}}|D] \}}||||q |t|fS)zBReturn (pkg_xml_rels, parts) pair resulting from loading pkg_file.)_parts _xml_relsitemsload_rels_from_xmlr)r$r}xml_relsrgrZr%r%r&rLs z_PackageLoader._load_ContentTypeMapcCst|jtS)z|_ContentTypeMap| object providing content-types for items of this package. Provides a content-type (MIME-type) for any given partname. )rfrom_xml_package_readerrr;r%r%r&_content_typessz_PackageLoader._content_typesrcC t|jS)zE|PackageReader| object providing access to package-items in pkg_file.)rrGr;r%r%r&rrz_PackageLoader._package_readerdict[PackURI, Part]cs4|j|j|jfdddd|jDDS)aUdict {partname: Part} populated with parts loading from package. Among other duties, this collection is passed to each relationships collection so each relationship can resolve a reference to its target part when required. This reference can only be reliably carried out once the all parts have been loaded. c s.i|]}|vr|t|||dqS))blob) PartFactory)rjrg content_typesrZpackage_readerr%r& s z)_PackageLoader._parts..css|] }|dkr|VqdS)/Nr%rir%r%r& z(_PackageLoader._parts..)rrrrr;r%rr&rs z_PackageLoader._partsdict[PackURI, CT_Relationships]cs2itdfdd ttS) zdict {partname: xml_rels} for package and all package parts. This is used as the basis for other loading operations such as loading parts and populating their relationships. source_partnamerr]r cs^||<||j}|jD]}|jtjkrqt||j}|vr$q| |qdS)zAPopulate `xml_rels` dict by traversing relationships depth-first.N) rWr~relationship_lst targetModeRTMEXTERNALr from_rel_refr6 _xml_rels_for)rr]base_urirYtarget_partname load_relsr$Zvisited_partnamesrr%r&rs   z+_PackageLoader._xml_rels..load_relsN)rrr]r )rUrrr;r%rr&rs z_PackageLoader._xml_relsrgrr cCs*|j|}|durtSttt|S)aReturn CT_Relationships object formed by parsing rels XML for `partname`. A CT_Relationships object is returned in all cases. A part that has no relationships receives an "empty" CT_Relationships object, i.e. containing no `CT_Relationship` objects. N)rZ rels_xml_forr newr r)r$rgZrels_xmlr%r%r&r s  z_PackageLoader._xml_rels_forN)rCrDrr)rCrDrrrr)rr)rr)rr)rr)rr)rgrrr )r:r?r@rArIrr{rLrrrrrrr%r%r%r&rzs       rzc@seZdZdZ d,d-d d Zed.ddZed/ddZej d0ddZe d1ddZ d2ddZ e d3ddZ ed4d d!Zej d5d"d!Ze d6d$d%Zd7d(d)Ze d6d*d+ZdS)8r aBase class for package parts. Provides common properties and methods, but intended to be subclassed in client code to implement specific part behaviors. Also serves as the default class for parts that are not yet given specific behaviors. Nrgr content_typerrrr bytes | NonecCs||_||_||_||_dSrF) _partname _content_typer_blob)r$rgrrrr%r%r&rI!s z Part.__init__bytesrrcCs|||||S)zReturn `cls` instance loaded from arguments. This one is a straight pass-through, but subtypes may do some pre-processing, see XmlPart for an example. r%rMrgrrrr%r%r&r{*sz Part.loadcCs |jpdS)zContents of this package part as a sequence of bytes. Intended to be overridden by subclasses. Default behavior is to return the blob initial loaded during `Package.open()` operation. rr;r%r%r&r3 z Part.blobcCs ||_dS)zNote that not all subclasses use the part blob as their blob source. In particular, the |XmlPart| subclass uses its `self._element` to serialize a blob on demand. This works fine for binary parts though. Nr)r$rr%r%r&r<rcC|jS)z&Content-type (MIME-type) of this part.)rr;r%r%r&rEzPart.content_typerr r}rrPcCs|j|jj||dS)aTload _Relationships for this part from `xml_rels`. Part references are resolved using the `parts` dict that maps each partname to the loaded part with that partname. These relationships are loaded from a serialized package and so already have assigned rIds. This method is only used during package loading. N)r"r|rr~)r$rr}r%r%r&rJszPart.load_rels_from_xmlcCr)zPackage this part belongs to.)rr;r%r%r&rSrz Part.packagecCr)z@|PackURI| partname for this part, e.g. "/ppt/slides/slide1.xml".)rr;r%r%r&rgXrz Part.partnamecCs&t|tstdt|j||_dS)Nz.partname must be instance of PackURI, got '%s')r,r TypeErrorr9r:rr$rgr%r%r&rg]s   r7cCr)z:Collection of relationships from this part to other parts.r"r;r%r%r&r]esz Part.relsfilerDcCs\t|trt|d }|WdS1swYtt|dr*|d|S)zIReturn bytes of `file`, which is either a str path or a file-like object.rbNseekr)r,rrNreadcallablegetattrr)r$rfr%r%r&_blob_from_fileks    zPart._blob_from_filecCs t|jjS)z'Relationships from this part to others.)r7rr~r;r%r%r&r"xrOz Part._relsrF)rgrrrrrrr) rgrrrrrrrrrrr)rrrr)rr r}rrrP)rrrr)rgrr>)rrDrr)r:r?r@rArIrr{rrsetterrrrrrgr]rr"r%r%r%r&r s0            r cs^eZdZdZdfd d ZedddZedddZdddZ eddZ d ddZ Z S)!XmlPartzBase class for package parts containing an XML payload, which is most of them. Provides additional methods to the |Part| base class that take care of parsing and reserializing the XML payload and managing relationships to other parts. rgrrrrrelementrcstt||||||_dSrF)superrrI_element)r$rgrrr __class__r%r&rIs zXmlPart.__init__rrcCs||||tdt|dS)zsz*XmlPart._rel_ref_count..z list[str]z//@r:id)rsr rZxpathr3r%rr&rs$zXmlPart._rel_ref_count)rgrrrrrrr)rgrrrrrrrrr)r0rrr) r:r?r@rArIrr{rrrSrZr __classcell__r%r%rr&r~s     rc@s6eZdZUdZiZded<dddZedddZdS)rzConstructs a registered subtype of |Part|. Client code can register a subclass of |Part| to be used for a package blob based on its content type. zdict[str, type[Part]] part_type_forrgrrrrrrrrr cCs||}|||||SrF) _part_cls_forr{)rMrgrrrZ PartClassr%r%r&__new__s zPartFactory.__new__ type[Part]cCs||jvr |j|StS)zReturn the custom part class registered for `content_type`. Returns |Part| if no custom class is registered for `content_type`. )rr )rMrr%r%r&rs  zPartFactory._part_cls_forN) rgrrrrrrrrr )rrrr) r:r?r@rAr__annotations__rrrr%r%r%r&rs   rc@s2eZdZdZdddZdd d ZedddZdS)rzLValue type providing dict semantics for looking up content type by partname. overridesdict[str, str]defaultscCrrF) _overrides _defaults)r$rrr%r%r&rIrz_ContentTypeMap.__init__rgrrrcCsTt|tstdt|j||jvr|j|S|j|jvr$|j|jStd|)zBReturn content-type (MIME-type) for part identified by *partname*.z4_ContentTypeMap key must be , got %sz8no content-type for partname '%s' in [Content_Types].xml) r,rrr9r:rextrKeyErrorrr%r%r& __getitem__s       z_ContentTypeMap.__getitem__content_types_xmlrcCs@tdt|}tdd|jD}tdd|jD}|||S)zEReturn |_ContentTypeMap| instance populated from `content_types_xml`.rcs |] }|j|jfVqdSrF)ZpartNamelower contentType)rjor%r%r&r z+_ContentTypeMap.from_xml..csrrF) extensionrr)rjdr%r%r&rr)r rrZ override_lstZ default_lst)rMrZ types_elmrrr%r%r&rs z_ContentTypeMap.from_xmlN)rrrr)rgrrr)rrrr)r:r?r@rArIrrrr%r%r%r&rs   rc@seZdZdZdd dZd?ddZd@ddZdAddZ dBddZ dCd"d#Z dDd$d%Z d>d&d'Z ed(d)ZdEdFd.d/Z *dEdGd1d2ZedHd3d4ZedId6d7ZedJd9d:Zd;S)Kr7aCollection of |_Relationship| instances having `dict` semantics. Relationships are keyed by their rId, but may also be found in other ways, such as by their relationship type. |Relationship| objects are keyed by their rId. Iterating this collection has normal mapping semantics, generating the keys (rIds) of the mapping. `rels.keys()`, `rels.values()`, and `rels.items() can be used as they would be for a `dict`. rrcCrErF) _base_uri)r$rr%r%r&rIrJz_Relationships.__init__r0objectrr+cCs ||jvS)z9Implement 'in' operation, like `"rId7" in relationships`.rr3r%r%r& __contains__ z_Relationships.__contains__ _RelationshipcCs(z|j|WStytd|w)zJImplement relationship lookup by rId using indexed access, like rels[rId].zno relationship with key '%s')r"rr3r%r%r&rs    z_Relationships.__getitem__ Iterator[str]cCr)zDImplement iteration of rIds (iterating a mapping produces its keys).)iterr"r;r%r%r&__iter__rz_Relationships.__iter__rcCr)z,Return count of relationships in collection.)rsr"r;r%r%r&__len__ rz_Relationships.__len__rr2r cCs$|||}|dur|||S|S)zReturn str rId of `reltype` to `target_part`. The rId of an existing matching relationship is used if present. Otherwise, a new relationship is added and that rId is returned. N _get_matching_add_relationship)r$rr2 existing_rIdr%r%r&r.s z_Relationships.get_or_addr6cCs,|j||dd}|dur|j||ddS|S)zReturn str rId of external relationship of `reltype` to `target_ref`. The rId of an existing matching relationship is used if present. Otherwise, a new relationship is added and that rId is returned. T)r*Nr)r$rr6rr%r%r&r-s z!_Relationships.get_or_add_ext_relrr r}rrPcs6fdd}|j|jdd|DdS)zHReplace any relationships in this collection with those from `xml_rels`.c3sFjD]}|jtjkrt|j}|vrqt|VqdS)z?Filter out broken relationships such as those pointing to NULL.N) rrrINTERNALrrr6rr)Zrel_elmrgrr}rr%r&iter_valid_rels+s  z5_Relationships.load_from_xml..iter_valid_relscss|]}|j|fVqdSrFr)rjrYr%r%r&r9sz/_Relationships.load_from_xml..N)r"clearupdate)r$rrr}rr%rr&r|&s z_Relationships.load_from_xmlcCsD|j|}t|dkrtd|t|dkrtd||djS)zReturn target part of relationship with matching `reltype`. Raises |KeyError| if not found and |ValueError| if more than one matching relationship is found. rz*no relationship of type '%s' in collectionroz1multiple relationships of type '%s' in collection)_rels_by_reltypersr ValueErrorr2)r$rZrels_of_reltyper%r%r&r#;s      z _Relationships.part_with_reltypecCr!)zReturn |_Relationship| identified by `rId` after removing it from collection. The caller is responsible for ensuring it is no longer required. rQr3r%r%r&rRKs z_Relationships.popcs>t}fdd}|D]}||j|j|j|jq |jS)zbytes XML serialization of this relationship collection. This value is suitable for storage as a .rels file in an OPC package. Includes a `.iter_rels_in_numerical_order..c3s|] \}}|VqdSrFr%)rj_r0r;r%r&rer)sortedkeys)Zsorted_num_rId_pairsr;r%r&iter_rels_in_numerical_order]sz8_Relationships.xml..iter_rels_in_numerical_order)r rZadd_relr0rr6r*Zxml_file_bytes)r$Zrels_elmrrYr%r;r&xmlRs   z_Relationships.xmlFr(r)r*cCs0|j}t|j|||r tjntj|d|j|<|S)z6Return str rId of |_Relationship| newly added to spec.) target_moder() _next_rIdrrrrrr")r$rr(r*r0r%r%r&rls z _Relationships._add_relationship str | NonecCsD|j|D]}|j|kr q|jr|jn|j}||kr|jSqdS)zReturn optional str rId of rel of `reltype`, `target`, and `is_external`. Returns `None` on no matching relationship N)rr*r6r2r0)r$rr(r*rYZ rel_targetr%r%r&rxs  z_Relationships._get_matchingcCs<tt|dddD]}d|}||jvr|Sq td)zNext str rId available in collection. The next rId is the first unused key starting from "rId1" and making use of any gaps in numbering, e.g. 'rId2' for rIds ['rId1', 'rId3']. rorrpzrId%dzJProgrammingError: Impossible to have more distinct rIds than relationships)rrrsr"rt)r$ruZ rId_candidater%r%r&rs  z_Relationships._next_rIddict[str, _Relationship]cCsiS)zFdict {rId: _Relationship} containing relationships of this collection.r%r;r%r%r&r"sz_Relationships._relsdict[str, list[_Relationship]]cCs,tt}|D] }||j|q |S)zBdefaultdict {reltype: [rels]} for all relationships in collection.) collections defaultdictlistr^rappend)r$DrYr%r%r&rs  z_Relationships._rels_by_reltypeN)rr)r0rrr+)r0rrr)rr)rr)rrr2r rr)rrr6rrr)rrrr r}rrrPr<r=)rrr(r)r*r+rr)rrr(r)r*r+rrr)rr)rr)r:r?r@rArIrrrrr.r-r|r#rRrrrrrrr"rr%r%r%r&r7s.            r7rc@s|eZdZdZd"d d Zed#ddZed$ddZed%ddZ ed%ddZ ed&ddZ ed'ddZ ed%dd Z d!S)(rzDValue object describing link from a part or package to another part.rrr0rrr(r)cCs"||_||_||_||_||_dSrF)r_rId_reltype _target_mode_target)r$rr0rrr(r%r%r&rIs  z_Relationship.__init__rYrr}rrcCs:|jtjkr |jn|t||j}|||j|j|j|S)zEReturn |_Relationship| object based on CT_Relationship element `rel`.)rrrr6rrr0r)rMrrYr}r(r%r%r&rs z_Relationship.from_xmlr+cCs |jtjkS)zTrue if target_mode is `RTM.EXTERNAL`. An external relationship is a link to a resource outside the package, such as a web-resource (URL). )r rrr;r%r%r&r*s z_Relationship.is_externalcCr)zHMember of RELATIONSHIP_TYPE describing relationship of target to source.)r r;r%r%r&rrz_Relationship.reltypecCr)zstr relationship-id, like 'rId9'. Corresponds to the `Id` attribute on the `CT_Relationship` element and uniquely identifies this relationship within its peers for the source-part or package. )r r;r%r%r&r0sz_Relationship.rIdr cCs$|jrtdt|jtsJ|jS)z3|Part| or subtype referred to by this relationship.zR`.target_part` property on _Relationship is undefined when target-mode is external)r*rr,r r r;r%r%r&r2s z_Relationship.target_partrcCs&|jrtdt|jtsJ|jjS)z|PackURI| instance containing partname targeted by this relationship. Raises `ValueError` on reference if target_mode is external. Use :attr:`target_mode` to check before referencing. zV`.target_partname` property on _Relationship is undefined when target-mode is external)r*rr,r r rgr;r%r%r&rs z_Relationship.target_partnamecCs*|jrt|jts J|jS|j|jS)zstr reference to relationship target. For internal relationships this is the relative partname, suitable for serialization purposes. For an external relationship it is typically a URL. )r*r,r rrZ relative_refrr;r%r%r&r6sz_Relationship.target_refN) rrr0rrrrrr(r))rrrYrr}rrr)rr+r)rr r)r:r?r@rArIrrrr*rr0r2rr6r%r%r%r&rs"       )5rA __future__rrtypingrrrrrrr pptx.opc.constantsr rr raZ pptx.opc.oxmlr r pptx.opc.packurirrrZpptx.opc.serializedrrZpptx.opc.sharedrZ pptx.oxmlr pptx.utilrtyping_extensionsrrrZpptx.oxml.xmlchemyr pptx.packagerpptx.parts.presentationrrrBrzr rrrrr7rr%r%r%r&s8 $         'eoe3$<