U d@sdZdZdZdZdZddlZddlZddlZddlZddl Z ddlm Z e dkr^dd l m Z n dd l m Z e dkrxe Zn dd l mZd d lmZd d lmZddlZddlZd dlTd dlmZmZmZd dlmZmZmZmZmZmZmZe dkrddlm Z!e dkrddl"m"Z"n ddl#m"Z"ddl Z Gddde$Z%Gddde$Z&ddZ'ddZ(ddZ)dd Z*Gd!d"d"e+Z,Gd#d$d$e-Z.Gd%d&d&e+Z/d'd(Z0ed)ed*ed+Z1d7d-d.Z2d/d0Z3d1d2Z4d3d4Z5d5d6Z6dS)8z A pure-Python PDF library with an increasing number of capabilities. See README for links to FAQ, documentation, homepage, etc. zMathieu Fenniakzbiziqe@mathieu.fenniak.netz Phaseit, Inc.zPyPDF3@phaseit.netN) version_info)r)StringIO)BytesIO)filters)utils)*)readNonWhitespacereadUntilWhitespaceConvertFunctionsToVirtualList)isStringb_u_ord_chr_str_ formatWarning)) ImmutableSet)r)md5c@seZdZdZddZddZddZdd Zd d Zd_d dZ ddZ ddZ d`ddZ daddZ ddZddZdbddZddZd d!Zdcd"d#Zddd&d'Zded)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zdfd5d6Zdgd7d8Zdhd:d;Zdd?Zd@dAZ didBdCZ!djdDdEZ"dkdFdGZ#dldHdIZ$dJdKdLdMdNdOdPgZ%dQdRZ&dSdTZ'e(e&e'Z)dUdVdWdXdYdZgZ*d[d\Z+d]d^Z,e(e+e,Z-dS)m PdfFileWriterz This class supports writing PDF files out, given pages produced by another class (typically :class:`PdfFileReader`). cCstd|_g|_t}|tdtdtdtdtdti|||_ t}|tdt t j t dd i|||_t}|tdtd td|j id|_||_dS) Nz%PDF-1.3/Type/Pages/Countr/Kids /ProducerZPyPDF3zutf-16bez/Catalog)r_header_objectsDictionaryObjectupdate NameObject NumberObject ArrayObject _addObject_pagescreateStringObjectcodecs BOM_UTF16_BErencode_info_root _root_object)selfpagesinforootr3./tmp/pip-unpacked-wheel-eeeohlmn/PyPDF3/pdf.py__init__Vs6   zPdfFileWriter.__init__cCs|j|tt|jd|S)Nr)r appendIndirectObjectlen)r/objr3r3r4r&ss zPdfFileWriter._addObjectcCs"|j|krtd|j|jdS)Nzpdf must be selfr)pdf ValueErrorr idnum)r/Zidor3r3r4 getObjectws zPdfFileWriter.getObjectcCs^|ddkst|j|td<||}||j}||d|t|dd|td<dS)Nr/Page/Parentrrr)AssertionErrorr'r#r&r=r$)r/pageactionr0r3r3r4_addPage|s   zPdfFileWriter._addPagecCs||tjdS)a Adds a page to this PDF file. The page is usually acquired from a :class:`PdfFileReader` instance. :param PageObject page: The page to add to the document. Should be an instance of :class:`PageObject` N)rClistr6)r/rAr3r3r4addPageszPdfFileWriter.addPagercs||fdddS)ao Insert a page in this PDF file. The page is usually acquired from a :class:`PdfFileReader` instance. :param PageObject page: The page to add to the document. This argument should be an instance of :class:`PageObject`. :param int index: Position at which the page will be inserted. cs ||SN)insert)lpindexr3r4z*PdfFileWriter.insertPage..N)rC)r/rArKr3rJr4 insertPages zPdfFileWriter.insertPagecCs||j}|d|S)a Retrieves a page by number from this PDF file. :param int pageNumber: The page number to retrieve (pages begin at zero) :return: the page at the index given by *pageNumber* :rtype: :class:`PageObject` rr=r')r/ pageNumberr0r3r3r4getPages zPdfFileWriter.getPagecCs||j}t|tdS)zC :return: the number of pages. :rtype: int r)r=r'intr#)r/r0r3r3r4 getNumPagess zPdfFileWriter.getNumPagesNcCst|||}|||S)a@ Appends a blank page to this PDF file and returns it. If no page size is specified, use the size of the last page. :param float width: The width of the new page expressed in default user space units. :param float height: The height of the new page expressed in default user space units. :return: the newly appended page :rtype: :class:`PageObject` :raises PageSizeNotDefinedError: if width and height are not defined and previous page does not exist. ) PageObjectcreateBlankPagerE)r/widthheightrAr3r3r4 addBlankPages zPdfFileWriter.addBlankPagecCs\|dks |dkr>|d|kr>||}|j}|j}t|||}||||S)at Inserts a blank page to this PDF file and returns it. If no page size is specified, use the size of the last page. :param float width: The width of the new page expressed in default user space units. :param float height: The height of the new page expressed in default user space units. :param int index: Position to add the page. :return: the newly appended page :rtype: :class:`PageObject` :raises PageSizeNotDefinedError: if width and height are not defined and previous page does not exist. Nr)rSrQmediaBoxgetWidth getHeightrTrUrN)r/rVrWrKZoldpagerAr3r3r4insertBlankPages    zPdfFileWriter.insertBlankPagec Cst}|tdtdtdtdtdtd|i||}tt}t}|tdttdtt||gii|||j td|td|id S) a Add Javascript which will launch upon opening this PDF. :param str javascript: Your Javascript. >>> output.addJS("this.print({bUI:true,bSilent:false,bShrinkToFit:true});") # Example: This will launch the print window when the PDF is opened. rz/Action/Sz /JavaScriptz/JSz(%s)/Namesz /OpenActionN) r!r"r#r&struuiduuid4r%r(r.)r/Z javascriptZjsZjs_indirect_objectZjs_string_nameZ js_name_treer3r3r4addJSs4     zPdfFileWriter.addJScCst}|||tdtdit}|td|it}|tdtdtdt|td|it}|tdtt||git}|td|i|jtd|idS) a Embed a file inside the PDF. :param str fname: The filename to display. :param str fdata: The data in the file. Reference: https://www.adobe.com/content/dam/Adobe/en/devnet/acrobat/pdfs/PDF32000_2008.pdf Section 7.11.3 rz /EmbeddedFile/Fz /Filespecz/EFr^z/EmbeddedFilesN)DecodedStreamObjectZsetDatar"r#r!r(r%r.)r/fnamefdataZ file_entryZefEntryZfilespecZembeddedFilesNamesDictionaryZembeddedFilesDictionaryr3r3r4 addAttachments>  zPdfFileWriter.addAttachmentcCsV|}|}td|D]6}||}|||||}t|r||qdS)aX Copy pages from reader to writer. Includes an optional callback parameter which is invoked after pages are appended to the writer. :param reader: a PdfFileReader object from which to copy page annotations to this writer object. The writer's annots will then be updated :callback after_page_append (function): Callback function that is invoked after each page is appended to the writer. Callback signature: :param writer_pageref (PDF page reference): Reference to the page appended to the writer. rN)rSrangerQrEcallable)r/readerafter_page_appendZreader_num_pagesZwriter_num_pagesZrpagenumZ reader_pageZ writer_pager3r3r4appendPagesFromReaderIs  z#PdfFileWriter.appendPagesFromReadercCs^tdt|dD]F}|d|}|D],}|d|kr*|tdt||iq*qdS)ai Update the form field values for a given page from a fields dictionary. Copy field texts and values from fields to page. :param page: Page reference from PDF writer where the annotations and field data will be updated. :param fields: a Python dictionary of field names (/T) and text values (/V) r/Annots/T/VN)rhr8r=getr"r#TextStringObject)r/rAfieldsjZ writer_annotfieldr3r3r4updatePageFormFieldValuescs  z'PdfFileWriter.updatePageFormFieldValuescCs|jd|_dS)z Copy the reader document root to the writer. :param reader: PdfFileReader from the document root should be copied. :callback after_page_append /RootN)trailerr.)r/rjr3r3r4cloneReaderDocumentRootvsz%PdfFileWriter.cloneReaderDocumentRootcCs|||||dS)a2 Create a copy (clone) of a document from a PDF file reader :param reader: PDF file reader instance from which the clone should be created. :callback after_page_append (function): Callback function that is invoked after each page is appended to the writer. Signature includes a reference to the appended page (delegates to appendPagesFromReader). Callback signature: :param writer_pageref (PDF page reference): Reference to the page just appended to the document. N)rxrl)r/rjrkr3r3r4cloneDocumentFromReaders z%PdfFileWriter.cloneDocumentFromReaderTFcCsdd}ddl}ddl} |dkr$|}|r:d} d} td} nd} d} td } ||||} tt||| | }tttt|}tttt| }t ||f|_ | dkrt ||| |\}}n$| dkst t || | || |d \}}t}td |td <t| |td <| dkr2t| d|td<t| |td<t||td<t||td<t| |td<|||_||_dS)a Encrypt this PDF file with the PDF Standard encryption handler. :param str user_pwd: The "user password", which allows for opening and reading the PDF file with the restrictions provided. :param str owner_pwd: The "owner password", which allows for opening the PDF files without any restrictions. By default, the owner password is the same as the user password. :param bool use_128bit: flag as to whether to use 128bit encryption. When false, 40bit encryption will be used. By default, this flag is on. :param bool allow_printing: flag as to whether to restrict permissions to allow printing. By default, this flag is on. :param bool allow_commenting: flag as to whether to restrict permissions to allow commenting. By default, this flag is on. :param int overwrite_permission: Manually set value of PDF document's /P flag cSsH|dk rt|tkrt|S|r(|s(dS|r4|r4dS|s@|r@dSdSdS)Nii$ir)typerR)ZprintingZ commentingZ permissionr3r3r4set_permissionssz.PdfFileWriter.encrypt..set_permissionsrNrrg0@rg@F /Standard/Filterro/Length/R/O/U/P)timerandomrRByteStringObject_alg33rrreprdigestr%_ID_alg34r@_alg35r!r#r$r&_encrypt _encrypt_key)r/user_pwd owner_pwdZ use_128bitZallow_printingZallow_commentingZoverwrite_permissionr{rrVrevkeylenPOZID_1ZID_2Ukeyencryptr3r3r4rs>      zPdfFileWriter.encrypttqdmcCst|dr$d|jkr$td|jd}ddl}|jsD||j|_i}t t |j D]~}|j |}t |t rV|jdkrV|j} | j|kri|| j<| j|| jkri|| j| j<t|dd||| j| j| j<qVg|_|rtd|d |jf|||j|`g} ||jtd |td t |j d kr|r|d krdtjkrddl} t t |j D]} | jd| dt |j dddsq| d} |j | }| ||tt| dd}t|drj| |j jkrj|!d| ddd}|!dddd}|j"||}t |t |j"dksBt#t$|%}|dt&dt |j"d}|'|||tdqln`t |j d kr|r|dkrdtjkrddl(m(}|t t |j dt |j dd}nt t |j }|D]} | d} |j | }| ||tt| dd}t|dr| |j jkr|!d| ddd}|!dddd}|j"||}t |t |j"dkst#t$|%}|dt&dt |j"d}|'|||tdq|}|td|td t |j d|td!d"| D]}|td#|dfq4|td$t)}|*t+d%t,t |j dt+d&|jt+d'|j-it|d(r|j.|t+d)<t|dr|j |t+d*<|'|d|td+|dS),z Writes the collection of pages added to this object out as a PDF file. :param stream: An object to write the file to. The object must support the write method and the tell method, similar to a file object. modebzPFile <%s> to write to is not in binary mode. It may not be written to correctly.FrNrzERM:zroot: u %âãÏÓ gui PySimpleGUIzEncrypting PDFhprogress)Z orientationrz 0 obj r|j|kr |j|jkr|S|j|j||}||||SqBt|jdr8|jjjr8td|jjj||ji|ji|jd} | dkr8z|j|} |jdt |j} t | d|} |j|kri||j<|j||jkri||j|j<| ||j|j|j<||| } | |j| d<| WSttfk r6td|jj|tYSX| Sn|SdS)NFZTYPErz I/O operation on closed file: {}rrz8Unable to resolve [{}: {}], returning NullObject instead) r __class____name__rr!rDrr StreamObjectr&r%rhr8r7r:r<rr6r=rrclosedr;formatrrprr RecursionErrorrr NullObject) r/Z externMaprrrrZ origvaluerZrealdataZnewobjr<Z newobj_idor3r3r4rOsf              "         z&PdfFileWriter._sweepIndirectReferencescCs0|j|d}t|d|}||ks,t|S)Nrr)r rKr7r=r@)r/r9r<refr3r3r4 getReferences zPdfFileWriter.getReferencecCsnd|jkrB|jd}|j|d}t|d|}||ksjtn(t}|i||}||jt d<|S)N /Outlinesrr) r.r rKr7r=r@ TreeObjectr"r&r#)r/outliner< outlineRefr3r3r4getOutlineRoots     zPdfFileWriter.getOutlineRootcCs@d|jkrt|jdtr|jd}|j|d}t|d|}||ksPtd|krt|dtr|d}|j|d}t|d|}||kstd|kr|d}qt}||t d<n.t}| |}||t d<t}||t d<nLt}| |}||jt d<t}| |}||t d<t}||t d<|S)Nr^rr/Dests) r.rr!r rKr7r=r@r%r#r&)r/namesr<ZnamesRefZdestsZdestsRefndr3r3r4getNamedDestRoots8          zPdfFileWriter.getNamedDestRootcCs6||}|}|dkr|}|}||||SrF)r&rr=addChild)r/destparentdestRefrr3r3r4addBookmarkDestinations  z$PdfFileWriter.addBookmarkDestinationc Cst}t|D]\}}||tt|<q||d|krt}t|dD]\}}||tt|<qT||}||td<||}|} |dkr| }| }| |||S)N/A) rrDrr#r_r"r!r&rr=r) r/bookmarkrZ bookmarkObjkvrB actionRef bookmarkRefrr3r3r4addBookmarkDicts"     zPdfFileWriter.addBookmarkDict/FitcGs\||jd|} t} g} |D](} | dk r>| t| q"| tq"ttd|d| t|f| } | }| td|tdtdi| | }| }|dkr|}t }| td|td t |i|dk r| td td d |Did }|r|d7}|r|d7}|r:| tdt|i| |}|}||||S)aG Add a bookmark to this PDF file. :param str title: Title to use for this bookmark. :param int pagenum: Page number this bookmark will point to. :param parent: A reference to a parent bookmark to create nested bookmarks. :param tuple color: Color of the bookmark as a red, green, blue tuple from 0.0 to 1.0 :param bool bold: Bookmark is bold :param bool italic: Bookmark is italic :param str fit: The fit of the destination page. See :meth:`addLink()` for details. rN/z bookmark/Dr]/GoTor/Titlez/CcSsg|] }t|qSr3) FloatObject).0cr3r3r4 sz-PdfFileWriter.addBookmark..rrrrc)r=r'r!r6r$r Destinationr# getDestArrayr"r&rrr(r%r)r/titlepagenumrcolorZboldZitalicfitrpageRefrBzoomArgsar destArrayrrrrrr3r3r4 addBookmarksN"    zPdfFileWriter.addBookmarkcCs(||}|}||d|g|SNr)r&rextend)r/rrrr3r3r4addNamedDestinationObject&s z'PdfFileWriter.addNamedDestinationObjectcCsn||jd|}t}|tdt|tdtdgtdtdi||}|}| ||g|S)Nrrz/FitHi:r]r) r=r'r!r"r#r%r$r&rr)r/rrrrrrr3r3r4addNamedDestination.s z!PdfFileWriter.addNamedDestinationcCs6||jd}|D]}||}d|kr|d=qdS)zA Removes links and annotations from this output. rrmNrO)r/r0rArr3r3r4 removeLinks=s  zPdfFileWriter.removeLinksc CsL||jd}tt|D](}||}||}|d}t|tsTt||}g}d}|jD]\} } | tdkr| d} |rt| tst| d<n| tdkr| d} |rt| tst| d<n|| tdkr| d} |rt| tst| d<nN| td krDtt| dD].} |rt| d| tst| d| <q| td krVd }| td krhd}|r| td tdtdtdtdtdtdtdtdtdtdtdtdtdtdtdtdtdtdtd td!td"td#td$td%fkrqb| td&kr qb| | | fqb||_| t d|qd'S)( Removes images from this output. :param bool ignoreByteStringObject: optional parameter to ignore ByteString Objects. r /ContentsFTjr'"rTJqTQcmwJrsMdrirZgsWrsSfFnmrHrryrBZDoshreN) r=r'rhr8r ContentStream operationsrrqr6 __setitem__r#) r/ignoreByteStringObjectr0rsrArcontentZ _operationsZ seq_graphicsoperandsoperatortextrr3r3r4 removeImagesGsx             2zPdfFileWriter.removeImagesc Cs||jd}tt|D]}||}||}|d}t|tsTt||}|jD]\}}|tdkr|d} |st| trt|d<nt| tst| t rt|d<qZ|tdkr|d} |st| trt|d<n t| tst| t rt|d<qZ|tdkr\|d} |s8t| trZt|d<n"t| tsPt| t rt|d<qZ|tdkrZtt|dD]f} |st|d| trt|d| <n6t|d| tst|d| t rxt|d| <qxqZ| t d|qd S) rrrrrrrrrN) r=r'rhr8rrrrrqrrr#) r/rr0rsrArrr r!r"rr3r3r4 removeTextsZ                  zPdfFileWriter.removeTextc CsX||jd|}||}|dk rjdd|ddD}t|dkrxtdd|dD}||ntdgd}t|rt|}nt|t rnt |}t } | td td td t |it } | td td td tdtd|td|tdtdtdt|td| i| | } d|krB|d| nt| g|td<dS)a Add an URI from a rectangular area to the specified page. This uses the basic structure of AddLink :param int pagenum: index of the page on which to place the URI action. :param int uri: string -- uri of resource to link to. :param rect: :class:`RectangleObject` or array of four integers specifying the clickable rectangular area ``[xLL, yLL, xUR, yUR]``, or string in the form ``"[ xLL yLL xUR yUR ]"``. :param border: if provided, an array describing border-drawing properties. See the PDF spec for details. No border will be drawn if this argument is omitted. REMOVED FIT/ZOOM ARG -John Mulligan rNcSsg|] }t|qSr3r#rrr3r3r4rsz(PdfFileWriter.addURI..rrcSsg|] }t|qSr3r%r&r3r3r4rsrr]z/URIr/Annot/Subtype/Linkr/Rectz/Hz/I/Borderrrm)r=r'r8r%r6r$r r#rRectangleObjectr!r"rqr&) r/rurirectborderpageLinkr borderArr dashPatternZlnk2lnklnkRefr3r3r4addURIsR       zPdfFileWriter.addURIcGs||jd|}||jd|}||} |dk r~dd|ddD} t|dkrtdd|dD} | | ntdgd} t|rt|}nt|t rnt |}g} |D](} | dk r| t| q| t qt td |t|f| }| }t }|td td td td td|td|tdt| td|i||}d| krv| d|nt|g| td<dS)a Add an internal link from a rectangular area to the specified page. :param int pagenum: index of the page on which to place the link. :param int pagedest: index of the page to which the link should go. :param rect: :class:`RectangleObject` or array of four integers specifying the clickable rectangular area ``[xLL, yLL, xUR, yUR]``, or string in the form ``"[ xLL yLL xUR yUR ]"``. :param border: if provided, an array describing border-drawing properties. See the PDF spec for details. No border will be drawn if this argument is omitted. :param str fit: Page fit or 'zoom' option (see below). Additional arguments may need to be supplied. Passing ``None`` will be read as a null value for that coordinate. Valid zoom arguments (see Table 8.2 of the PDF 1.7 reference for details): /Fit No additional arguments /XYZ [left] [top] [zoomFactor] /FitH [top] /FitV [left] /FitR [left] [bottom] [right] [top] /FitB No additional arguments /FitBH [top] /FitBV [left] rNcSsg|] }t|qSr3r%r&r3r3r4rsz)PdfFileWriter.addLink..rrcSsg|] }t|qSr3r%r&r3r3r4rsrz /LinkNamerr'r(r)rr*r+/Destrm)r=r'r8r%r6r$r r#rr,rrrr!r"r&)r/rZpagedestr.r/rrr0ZpageDestrr1r2rrrrr3r4r3r3r4addLinksT       zPdfFileWriter.addLinkz /NoLayoutz /SinglePagez /OneColumnz/TwoColumnLeftz/TwoColumnRightz /TwoPageLeftz /TwoPageRightcCs(z |jdWStk r"YdSXdS)z Get the page layout. See :meth:`setPageLayout()` for a description of valid layouts. :return: Page layout currently being used. :rtype: str, None if not specified /PageLayoutNr.KeyErrorr/r3r3r4 getPageLayout9s zPdfFileWriter.getPageLayoutcCsLt|ts4||jkr,tdd|jt|}|jtd|idS)a Set the page layout :param str layout: The page layout to be used Valid layouts are: /NoLayout Layout explicitly not specified /SinglePage Show one page at a time /OneColumn Show one column at a time /TwoColumnLeft Show pages in two columns, odd-numbered pages on the left /TwoColumnRight Show pages in two columns, odd-numbered pages on the right /TwoPageLeft Show two pages at a time, odd-numbered pages on the left /TwoPageRight Show two pages at a time, odd-numbered pages on the right zLayout should be one of: {}, r8N) rr#_valid_layoutsrrrjoinr.r")r/Zlayoutr3r3r4 setPageLayoutFs   zPdfFileWriter.setPageLayoutz/UseNonez /UseOutlinesz /UseThumbsz /FullScreenz/UseOCz/UseAttachmentscCs(z |jdWStk r"YdSXdS)z Get the page mode. See :meth:`setPageMode()` for a description of valid modes. :return: Page mode currently being used. :rtype: str, None if not specified /PageModeNr9r;r3r3r4 getPageModeas  zPdfFileWriter.getPageModecCsLt|ts4||jkr,tdd|jt|}|jtd|idS)a Set the page mode. :param str mode: The page mode to use. Valid modes are: /UseNone Do not show outlines or thumbnails panels /UseOutlines Show outlines (aka bookmarks) panel /UseThumbs Show page thumbnails panel /FullScreen Fullscreen view /UseOC Show Optional Content Group (OCG) panel /UseAttachments Show attachments panel zMode should be one of: {}r=rAN) rr# _valid_modesrrrr?r.r")r/rr3r3r4 setPageModeos   zPdfFileWriter.setPageMode)r)NN)NNr)N)N)NTTFN)Fr)N)N)NNFFr)F)F)N)Nr).r __module__ __qualname____doc__r5r&r=rCrErNrQrSrXr\rbrgrlrurxryrrrrrrrrrrrrrr#r$r5r7r>r<r@property pageLayoutrCrBrDpageModer3r3r3r4rPs^    !P   B r <#   = 8 6 : G    rc@seZdZdZdPddZddZedd ddZd d Zed d ddZ d dZ edd ddZ ddZ edd ddZ dQddZddZddZddZddZdRddZedd ddZdSd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zed,d ddZd-d.ZeeZd/d0ZeeZdTd1d2Z d3d4Z!d5d6Z"d7d8Z#d9d:Z$d;d<Z%d=d>Z&d?d@Z'dAdBZ(dCdDZ)dEdFZ*dGdHZ+dIdJZ,dKdLZ-dMdNZ.edOd ddZ/dS)U PdfFileReadera  Initializes a PdfFileReader object. This operation can take some time, as the PDF stream's cross-reference tables are read into memory. :param stream: A File object or an object that supports the standard read and seek methods similar to a File object. Could also be a string representing a path to a PDF file. :param bool strict: Determines whether user should be warned of all problems and also causes some correctable problems to be fatal. Defaults to ``True``. :param warndest: Destination for logging warnings (defaults to ``sys.stderr``). :param bool overwriteWarnings: Determines whether to override Python's ``warnings.py`` module with a custom implementation (defaults to ``True``). TNcCs|r|dfdd}|t_||_d|_i|_d|_d|_t|drXd|jkrXt dt j t |rt |d}tt|}|||||_d|_dS) NcSsB|dkrtj}z|t|||||Wntk r<YnXdSrF)rstderrrrIOError)messagecategoryfilenamelinenofileliner3r3r4 _showwarnings z,PdfFileReader.__init__.._showwarningrrrzUPdfFileReader stream/file object is not in binary mode. It may not be read correctly.rbF)r showwarningstrictflattenedPagesresolvedObjects xrefIndex _pageId2NumrrrrPdfReadWarningr openrrreadcloser_override_encryption)r/rrWZwarndestZoverwriteWarningsrTfileobjr3r3r4r5s&  zPdfFileReader.__init__cCs,d|jkrdS|jd}t}|||S)a Retrieves the PDF file's document information dictionary, if it exists. Note that some PDF files use metadata streams instead of docinfo dictionaries, and these metadata streams will not be accessed by this function. :return: the document information of this PDF file :rtype: :class:`DocumentInformation` or ``None`` if none exists. rN)rwDocumentInformationr")r/r9retvalr3r3r4getDocumentInfos   zPdfFileReader.getDocumentInfocCs|SrF)rdr;r3r3r4rLrMzPdfFileReader.cCs&zd|_|jdWSd|_XdS)az Retrieves XMP (Extensible Metadata Platform) data from the PDF document root. :return: a :class:`XmpInformation` instance that can be used to access XMP metadata from the document. :rtype: :class:`XmpInformation` or ``None`` if no metadata was found on the document root. FTrvN)r`rwgetXmpMetadatar;r3r3r4res zPdfFileReader.getXmpMetadatacCs|SrF)rer;r3r3r4rLrMcCsv|jrVzDz(d|_|d|jdddWWStdYnXW5d|_Xn|jdkrh|t|jSdS) z Calculates the number of pages in this PDF file. :return: number of pages :rtype: int :raises PdfReadError: if file is encrypted and restrictions prevent this action. FTrvrrzFile has not been decryptedN) isEncryptedr`decryptrwr PdfReadErrorrX_flattenr8r;r3r3r4rSs    zPdfFileReader.getNumPagescCs|SrF)rSr;r3r3r4rLrMcCs|jdkr||j|S)a Retrieves a page by number from this PDF file. :param int pageNumber: The page number to retrieve (pages begin at zero) :return: a :class:`PageObject` instance. :rtype: :class:`PageObject` N)rXrj)r/rPr3r3r4rQs zPdfFileReader.getPagecCs|SrF)getNamedDestinationsr;r3r3r4rLsc Csddddddddd }|d krBi}|jd }d |kr>|d }nd S|d krN|S|||||D] }||kr`|||||qq`d |kr|d }|D]}|} || |||q|S)a$ Extracts field data if this PDF contains interactive form fields. The *tree* and *retval* parameters are for recursive use. :param fileobj: A file object (usually a text file) to write a report to on all interactive form fields found. :return: A dictionary where each key is a field name, and each value is a :class:`Field` object. By default, the mapping name is used for keys. :rtype: dict, or ``None`` if form data could not be located. z Field TypeZParentz Field NamezAlternate Field Namez Mapping Namez Field FlagsValuez Default Value)/FTr?rn/TU/TM/Ffro/DVNrvz /AcroFormz/Fields)rw _checkKids _buildFieldr=) r/treercrafieldAttributescatalogattrrrrrtr3r3r4 getFieldss6   zPdfFileReader.getFieldsc Cs||||z |d}Wn:tk rTz |d}Wntk rNYYdSXYnX|rr|||||dt|||<dS)Nrornr)rrr: _writeFieldrZField)r/rtrcrarurr3r3r4rsFs   zPdfFileReader._buildFieldcCs,d|kr(|dD]}||||qdS)Nr)rxr=)r/rtrcrakidr3r3r4rrUs zPdfFileReader._checkKidsc Csddddddddg}|D]}||}z|dkrhd d d d d }|||kr||d|||dnp|dkrz|dd}Wn tk r|dd}YnX||d|dn||dt||dWqtk rYqXqdS)Nrornrmr?rnrprorqZButtonTextZChoice Signature)z/Btn/Txz/Chz/Sigz: r)rr:r_) r/rartruorderrwattrNametypesrr3r3r4ry[s&  "zPdfFileReader._writeFieldcs|tfddDS)zW Retrieves form fields from the document with textual data (inputs, dropdowns) c3s:|]2}|ddkr|d|dfVqdS)rmr}rnroNrp)rrtZ formfieldsr3r4 xsz2PdfFileReader.getFormTextFields..)rxdictr;r3rr4getFormTextFieldsss zPdfFileReader.getFormTextFieldsc Cs|dkrHi}|jd}d|kr(|d}n d|krH|d}d|krH|d}|dkrT|Sd|krz|dD]}|||qdd|kr|d}tdt|dD]V}||}||d}t|trd |kr|d }|||} | dkr| ||<q|S) z Retrieves the named destinations present in the document. :return: a dictionary which maps names to :class:`Destinations`. :rtype: dict Nrvrr^rrrrr)rwrkr=rhr8rr!_buildDestination) r/rtrcrvrrzrrvalrr3r3r4rk}s2      z"PdfFileReader.getNamedDestinationscCs|SrF) getOutlinesr;r3r3r4rLrMcCs|dkr`g}|jd}d|krVz |d}Wntjk rD|YSXd|krV|d}||_|dkrl|S||}|r||d|krg}||d||r||d|krq|d}ql|S)z Retrieves the document outline present in the document. :return: a nested list of :class:`Destinations`. Nrvr/Firstz/Next)rwrrirk _namedDests _buildOutliner6r)r/nodeoutlinesrvlinesrZ subOutlinesr3r3r4rs2        zPdfFileReader.getOutlinescCs\|jdkr4i}t|jD]\}}|||jj<q||_t|trD|}n|j}|j|d}|S)zGenerate _pageId2NumN)r[ enumerater0rr<rrRrp)r/rZid2numrxr<retr3r3r4_getPageNumberByIndirects  z&PdfFileReader._getPageNumberByIndirectcCs|j}||}|S)a Retrieve page number of a given PageObject :param PageObject page: The page to get page number. Should be an instance of :class:`PageObject` :return: the page number or -1 if page not found :rtype: int )rr)r/rArrr3r3r4 getPageNumbers  zPdfFileReader.getPageNumbercCs|j}||}|S)a> Retrieve page number of a given Destination object :param Destination destination: The destination to get page number. Should be an instance of :class:`Destination` :return: the page number or -1 if page not found :rtype: int )rAr)r/Z destinationrrr3r3r4getDestinationPageNumbers  z&PdfFileReader.getDestinationPageNumbercCs.|dd\}}|dd}t|||f|S)Nrr)r)r/rarrayrAtypr3r3r4rs zPdfFileReader._buildDestinationcCsd\}}}d|kr@d|kr@|d}|d}|ddkr`|d}n d|kr`d|kr`|d}|d}|rt|tr||||}n8t|r||jkr|j|}||td<ntd||S) N)NNNrrr]rrr6zUnexpected destination %r)rr%rr rr#rri)r/rrrrrBr3r3r4r s"     zPdfFileReader._buildOutlinecCst|j|jSrF)r rSrQr;r3r3r4rL#rMcCs,z|jddWStk r&YdSXdS)z Get the page layout. See :meth:`setPageLayout()` for a description of valid layouts. :return: Page layout currently being used. :rtype: ``str``, ``None`` if not specified rvr8Nrwr:r;r3r3r4r<+s zPdfFileReader.getPageLayoutcCs,z|jddWStk r&YdSXdS)z Get the page mode. See :meth:`setPageMode()` for a description of valid modes. :return: Page mode currently being used. :rtype: ``str``, ``None`` if not specified rvrANrr;r3r3r4rB=s zPdfFileReader.getPageModec Cstdtdtdtdf}|dkr*t}|dkrRg|_|jd}|d}d}d|krf|d}|dkr|D]}||krr||||<qr|dD].}i} t|tr|| d <|j||f| qnP|d krt| D]\}} ||kr| ||<qt ||} | ||j | dS) N /Resources /MediaBox/CropBox/Rotatervrrrrr>) r#rrXrwr=rr7rjrDrrTr"r6) r/r0ZinheritrZinheritablePageAttributesrvtrwrAZaddtrZpageObjr3r3r4rjOs<       zPdfFileReader._flattenc Cs d}|j|j\}}|r(td||ft|d|}|rRtd|||f|ddksbt||dksrttt|}t |dD]b}t || dd t |}t || dd t |} t || dd ||jkrq|jr ||kr td | |d | d|rp|} | dd|} t dt| D]}t| |qP| | dzt||} Wnltjk r} zJtd } td ||j|j| ftj|jrtd | t} W5d} ~ XYnX| S|jrtdtS)NFz Here1: %s %srz$Here2: objStm=%s.. stmnum=%s data=%srz/ObjStmz/NrrzObject is in wrong index.rz1Invalid stream (index %d) within object %d %d: %szCan't read object stream: %sz%This is a fatal error in strict mode.) xref_objStmr<rr7r=getDatar@rrrhr seekr$ZreadFromStreamrWrrir readlinesr8 readObjectZPdfStreamErrorrexc_inforrrr\r)r/indirectReferencerZstmnumidxZobjStm streamDatarZobjnumrposrr9er3r3r4_getObjectFromStreamrs^           z"PdfFileReader._getObjectFromStreamc Cs8d}|rtd|j|jf||j|j}|dkr6|S|jdkrZ|j|jkrZ||}n|j|jkr|j|j|jkr|j|j|j}|rtd|j|jd|f|j|d| |j\}}||jkr|j r|j rt d|j|j||fnn&||jkr t d|j|j||f||jks0tt|j|}|js"|jr"t|dsbt d ddl}|d |jdd }|d |jdd } |j|| } t| t|jd kstt| } | dtdt|jd } ||| }n,td|j|jft j|j r"t d||j|j||S)NFz looking at:rz Uncompressed Object:zVExpected object ID (%d %d) does not match actual (%d %d); xref table not zero-indexed.z9Expected object ID (%d %d) does not match actual (%d %d)._decryption_keyzfile has not been decryptedrrrrrzObject %d %d not defined.zCould not find object.)rr<rcacheGetIndirectObjectrrxrefrrreadObjectHeaderrZrWrrir@rr`rgrrrrr8rrr_decryptObjectrrr\cacheIndirectObject) r/rrrcstartr<rrrrrrr3r3r4r=sv         zPdfFileReader.getObjectcCst|tst|tr(tt||j}n~t|trDt||j|_nbt|t rvt | D]\}}| ||||<qZn0t|t rtt|D]}| |||||<q|SrF)rrrqr(r RC4_encryptoriginal_bytesr_datar!rDrrr%rhr8)r/r9rZdictkeyrrr3r3r4rs   zPdfFileReader._decryptObjectcCsd}t||t|O}|ddt|}|t|O}|ddt|}|d}t||dd|r|jrt d||ftj t |t |fS)NFrrrz3Superfluous whitespace found in object header %s %s) rZskipOverCommentZskipOverWhitespacerr r^r rWrrr\rR)r/rextrar<rr9r3r3r4rs$      zPdfFileReader.readObjectHeadercCsFd}|j||f}|r.|r.td||fn|rBtd||f|S)NFzcache hit: %d %dzcache miss: %d %d)rYrpr)r/rr<routr3r3r4rsz$PdfFileReader.cacheGetIndirectObjectcCsH||f|jkr6d||f}|jr,t|n t|||j||f<|S)NzOverwriting cache for %s %s)rYrWrrirr)r/rr<r9msgr3r3r4r s   z!PdfFileReader.cacheIndirectObjectc) svd}|rtd||dd|s0td|dd}td}|dd td kr||krrtd |}|rHtd |qH|}z t|}WnJtk r| td stdt|dd }t dYn,X|}|ddtd krtdi_ i_t_||d|d}|tdkr|d}|ddtdkrztdt||ddd}t|} |r| dkr| _jrt dtjd}t||ddt|} t||ddd} | | kr|d}|dtdkrB|dd|d}q|dtdkr`|dd|ddtd\} } t| t| } } | j krij | <| j | krn| j | | <| d7} | d7} qt||dd|d}|td kr|d!dnqqt||ddt|}t|D] \}}|jkrB|j|<qBd"|kr|d"}nqq,|r|dd|\}} t|}|d#d$kst| ||tt|| d%d| d&g}|rtd't!|| d(t"dks,tjrPt"dkrPtd)fd*d+}fd,d-}d}!|D]$\}} ||kst|| }t#||| D]} |d}|dkr|d}|d}n|dkr0|d}|d} | j krij | <|| | s|j | | <|rtd.| | fnh|dkr|d}|d}d} || | s|rrtd/| ||f||fj| <njrtd0|qqxd1}|D]0}||kr|jkr|$|jt%|<qd"|kr|d"}nqn|dkr jrtd2nt d3q|d4d|d} | &td5}!|!dkr^|d6|!8}q,||dd}"t#d D](}#|drv||#7}d}"qqv|"rq,td7q,jrrjsr|}$j D]}%|%d8krqֈj |%D]n}&|j |%|&dz|\}'}(Wntk r<YqYnX|'|&jkr'|%q֐qq||$ddS)9NFz>>readrrzCannot read an empty fileirrfrz%%EOFzEOF marker not foundz line: startxrefzstartxref not found z startxref on same line as offsetrrrrrzxref table read errorTzFXref table not zero-indexed. ID numbers for objects will be corrected.z iZ 0123456789tr rwiz/Prevrz/XRefz/Indexrzread idx_pairs=%sz/WzToo many entry sizes: %scs<|dkr(|}t||S|dkr4dSdSdS)Nrr)r^ convertToInt)rr) entrySizesrr3r4getEntrys  z$PdfFileReader.read..getEntrycs|j|gkp|jkSrF)rrpr)numrr;r3r4 used_beforesz'PdfFileReader.read..used_beforezXREF Uncompressed: %s %szXREF Compressed: %s %s %szUnknown xref type: %s)rvrrrz6/Prev=0 in the trailer (try opening with strict=False)zA/Prev=0 in the trailer - assuming there is no previous xref tableir z/Could not find xref table at specified locationr)(rrrrrirreadNextEndLinerRr; startswithstriprrrrr!rwr^r rrZrWr\splitrDrisdigitrr@rrrrp_pairsr8rhraw_getr#find _zeroXref))r/rrZlast1KrSrrrZ firsttimersizeZcntrrZ trailertagZ newTrailerrrr<Z xrefstreamZ idx_pairsrrZlast_endrZ xref_typeZnext_free_objectZnext_generationZ byte_offsetZ objstr_numZ obstr_idxZ trailerKeystmpZxref_locfoundZlooklocgenidpidZpgenr3)rr/rr4r^sd                                                                zPdfFileReader.readcs.tfddtj|Dj|<dS)Nc3s |]\}}|j|fVqdSrF)rZ)rrrr;r3r4r sz*PdfFileReader._zeroXref..)rrDrr)r/rr3r;r4r szPdfFileReader._zeroXrefccs:d}||||dfV|d7}|dt|krq6qdS)Nrrr)r8)r/rrr3r3r4rs zPdfFileReader._pairscCsd}|rtdtd}|dkr.td|d}|rRtd|dt|f|d krhtd |d d|td ks|td krPd}|td ks|td kr4|rt|dkrtdnt|dkrtd|d}|td ks|td kr|ddd}|d kr&td |d dq||rBd nddqxq|r^td||}|rtd|fq|rtd|S)NFz>>readNextEndLinerfrz!Could not read malformed PDF filerz x:z%xrzEOL marker not foundr z x is CR 0Drz x is LF 0ArTz x is neitherz RNEL line:z leaving RNEL)rrrrrir^ordr)r/rrrSrZcrlfr3r3r4rsJ            zPdfFileReader.readNextEndLinecCs"d|_z||WSd|_XdS)a` When using an encrypted / secured PDF file with the PDF Standard encryption handler, this function will allow the file to be decrypted. It checks the given password against the document's user password and owner password, and then stores the resulting decryption key if either password is correct. It does not matter which password was matched. Both passwords provide the correct decryption key that will allow the document to be used with this library. :param str password: The password to match. :return: ``0`` if the password failed, ``1`` if the password matched the user password, and ``2`` if the password matched the owner password. :rtype: int :raises NotImplementedError: if document uses an unsupported encryption method. TFN)r`_decrypt)r/passwordr3r3r4rh<szPdfFileReader.decryptc Cs2|jd}|ddkr"td|ddkr>td|d||\}}|rZ||_dS|d }|d krtd }n|d d }t|||}|d}|d krt||}n^|} tdddD]H} t d} tt |D]"} | t t t || | A7} qt| | } q| }||\} }| r.||_d SdS)Nrr}r|z1only Standard PDF encryption handler is availablero)rrz@only algorithm code 1 and 2 are supported. This PDF uses code %srrrrrr~rrrfr) rwr=NotImplementedError_authenticateUserPasswordr_alg33_1rrrhrr8chrr)r/rrZ user_passwordrrrZreal_OZuserpassrrnew_keyrHZowner_passwordr3r3r4rVs>       zPdfFileReader._decryptc Cs|jd}|d}|d}|d}|jd}|d}|dj}|dkrvt||||\} } nV|d krt|||d d ||||d td \} } | dd|dd} }| |k| fS)Nrrrrrrrrrrr~z/EncryptMetadataFr)rwr=rrrrpZ BooleanObject) r/rrr owner_entryp_entryZid_entry id1_entryZreal_Urrr3r3r4rys&    z'PdfFileReader._authenticateUserPasswordcCs d|jkS)Nr)rwr;r3r3r4getIsEncryptedszPdfFileReader.getIsEncryptedcCs|SrF)rr;r3r3r4rLrM)TNT)NNN)NN)NN)NNN)0rrErFrGr5rdrHZ documentInforeZ xmpMetadatarSZnumPagesrQZnamedDestinationsrxrsrrryrrkrrrrrrrr0r<rIrBrJrjrr=rrrrr^rrrrhrrrrgr3r3r3r4rKsh  * ) .  #58   w%#rKcCsn||}t|tr|S|dkr@|D]}||}|dkr$q@q$t|trV|j|}t|}t||||SrF)rprr,r7r:r= setRectangle)r/rdefaultsrcrr3r3r4 getRectangles      rcCst|tst|}|||<dSrF)rr#)r/rrr3r3r4rs rcCs ||=dSrFr3)r/rr3r3r4deleteRectanglesrcs&tfddfddfddS)Ncs t|SrF)rr;fallbackrr3r4rLrMz)createRectangleAccessor..cs t||SrF)rr/rrr3r4rLrMcs t|SrF)rr;rr3r4rLrM)rH)rrr3rr4createRectangleAccessors    rc@sPeZdZdZd@ddZdAddZeeZddZd d Zd d Z d dZ ee Z ddZ ee Z ddZ ee Z ddZ ee Z ddZddZdBddZdCddZdDddZdEd d!ZdFd"d#ZdGd$d%ZdHd&d'ZdId(d)ZdJd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zed8d9Z ed:d;Z!edd=Z#ed?d=Z$dS)KrTa This class represents a single page within a PDF file. Typically this object will be created by accessing the :meth:`getPage()` method of the :class:`PdfFileReader` class, but it is also possible to create an empty page with the :meth:`createBlankPage()` static method. :param pdf: PDF file the page belongs to. :param indirectRef: Stores the original indirect reference to this object in its source PDF NcCst|||_||_dSrF)r!r5r:r)r/r:rr3r3r4r5s zPageObject.__init__cCst|}|tdtd|tdt|tdt|dksP|dkr|dk r|dkr||d}|j}|j }nt |tdt dd||g|S) aT Returns a new blank page. If ``width`` or ``height`` is ``None``, try to get the page size from the last page of *pdf*. :param pdf: PDF file the page belongs to :param float width: The width of the new page expressed in default user space units. :param float height: The height of the new page expressed in default user space units. :return: the new blank page: :rtype: :class:`PageObject` :raises PageSizeNotDefinedError: if ``pdf`` is ``None`` or contains no page rr>r?rNrrr) rTrr#rr!rSrQrYrZr[rZPageSizeNotDefinedErrorr,)r:rVrWrAZlastpager3r3r4rUs   zPageObject.createBlankPagecCs|ddkst|||S)z Rotates a page clockwise by increments of 90 degrees. :param int angle: Angle to rotate the page. Must be an increment of 90 deg. Zrr@_rotater/angler3r3r4rotateClockwises zPageObject.rotateClockwisecCs |ddkst|| |S)z Rotates a page counter-clockwise by increments of 90 degrees. :param int angle: Angle to rotate the page. Must be an increment of 90 deg. rrrrr3r3r4rotateCounterClockwises z!PageObject.rotateCounterClockwisecCs:|dd}t|tr|n|}t|||td<dS)Nrr)rprrRr=r$r#)r/rZ rotateObjZ currentAngler3r3r4r s zPageObject._rotatecCst}|||t||t}i}t|D]`}||kr||||krt|tt }|||<||||<q@||kr@||||<q@||fSrF) r!r"rpr=rDkeysrr#r_r`ra)Zres1Zres2resourceZnewResZpage2ResZ renameResrZnewnamer3r3r4_mergeResources szPageObject._mergeResourcescCsZ|s|St||}|jD]<\}}tt|D]&}||}t|tr,|||||<q,q|SrF)rrrhr8rr#rp)rrenamer:r r!ropr3r3r4_contentStreamRename s  zPageObject._contentStreamRenamecCs0t||}|jdgdg|jgdg|S)Nrrr )rrrGr6)contentsr:rr3r3r4 _pushPopGS( s zPageObject._pushPopGSc CsT|\}}}}}}t||}|jdt|t|t|t|t|t|gdg|S)Nrz cm)rrrGr) rr:ctmrrrrrrr3r3r4_addTransformationMatrix3 s z#PageObject._addTransformationMatrixcCsd|kr|dSdSdS)z Accesses the page contents. :return: the ``/Contents`` object, or ``None`` if it doesn't exist. ``/Contents`` is optional, as described in PDF Reference 7.7.3.3 rN)r=r;r3r3r4 getContents? s zPageObject.getContentscCs||dS)a Merges the content streams of two pages into one. Resource references (i.e. fonts) are maintained from both pages. The mediabox/cropbox/etc of this page are not altered. The parameter page's content stream will be added to the end of this page's content stream, meaning that it will be drawn after, or "on top" of this page. :param PageObject page2: The page to be merged into this one. Should be an instance of :class:`PageObject`. N _mergePage)r/page2r3r3r4 mergePageK s zPageObject.mergePageFc s t}i}|d}|d}t} ||fD]4} d| kr0| d} t| tr0| D]} | | qTq0dD]0} t||| \}}|rj||t| <| |qjtt |dt t |dt|td<t}| }|dk r|t ||j| }|dk rN|dk r&||}t|||j}t ||j}|||r|j|j|j|jg}|j|j|j|j|j|j|j|jgdk r>ddDfddtdd d D}fd dtdd d D}ndd d }d d d }t|t|g}t|t|g}t|d|dt|d |d g}t|d |dt|d |d g}|j||j|t||j|td<||td<| |td<dS)Nrrm)z /ExtGStatez/Fontz/XObjectz /ColorSpacez/Patternz/Shadingz /Propertiesz/ProcSetcSsg|] }t|qSr3)float)rrr3r3r4r sz)PageObject._mergePage..cs8g|]0}d|d|ddqS)rrrrr3rrZcorners2rr3r4r srr~rcs8g|]0}d|d|ddqS)rrrr3rrr3r4r srrr) r!r=r%rprr6rTrr#r" frozensetunionrrr:rrYgetLowerLeft_xZ as_numericgetLowerLeft_ygetUpperRight_xgetUpperRight_yZgetUpperLeft_xZgetUpperLeft_yZgetLowerRight_xZgetLowerRight_yrhrmaxZ setLowerLeftZ setUpperRightr)r/rZpage2transformationrexpandZ newResourcesrZoriginalResourcesZpage2ResourcesZ newAnnotsrAZannotsrresnewZ newrenameZnewContentArrayoriginalContent page2ContentZcorners1Znew_xZnew_yZ lowerleftZ upperrightr3rr4rX s                 $$   zPageObject._mergePagecs|fdd|dS)a This is similar to mergePage, but a transformation matrix is applied to the merged stream. :param PageObject page2: The page to be merged into this one. Should be an instance of :class:`PageObject`. :param tuple ctm: a 6-element tuple containing the operands of the transformation matrix :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. cst|jSrF)rTrr:)rrrr3r4rL sz1PageObject.mergeTransformedPage..Nr)r/rrr r3rr4mergeTransformedPage s zPageObject.mergeTransformedPagec Cs|||dd|ddg|S)a This is similar to mergePage, but the stream to be merged is scaled by appling a transformation matrix. :param PageObject page2: The page to be merged into this one. Should be an instance of :class:`PageObject`. :param float scale: The scaling factor :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rr)r/rscaler r3r3r4mergeScaledPage s zPageObject.mergeScaledPagec Cs>t|}||t|t|t| t|ddg|S)a This is similar to mergePage, but the stream to be merged is rotated by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float rotation: The angle of the rotation, in degrees :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. r)mathradiansrcossin)r/rrotationr r3r3r4mergeRotatedPage s  zPageObject.mergeRotatedPagec Cs||dddd||g|S)a This is similar to mergePage, but the stream to be merged is translated by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float tx: The translation on X axis :param float ty: The translation on Y axis :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rrr)r/rtxtyr r3r3r4mergeTranslatedPage s zPageObject.mergeTranslatedPagec Csdddgdddg| | dgg}t|}t|t|dgt| t|dgdddgg}dddgdddg||dgg}t||} t| |} ||| dd| dd| dd| dd| dd| ddg|S)aE This is similar to mergePage, but the stream to be merged is rotated and translated by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float tx: The translation on X axis :param float ty: The translation on Y axis :param float rotation: The angle of the rotation, in degrees :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rrrrrrrrmatrixMultiplyr) r/rrrrr  translationrotatingZ rtranslationrr3r3r4mergeRotatedTranslatedPage s.      z%PageObject.mergeRotatedTranslatedPagec Cst|}t|t|dgt| t|dgdddgg}|ddgd|dgdddgg}t||}|||dd|dd|dd|dd|dd|ddg|S)a  This is similar to mergePage, but the stream to be merged is rotated and scaled by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float rotation: The angle of the rotation, in degrees :param float scale: The scaling factor :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rrrr)r/rrrr r"scalingrr3r3r4mergeRotatedScaledPage s&    z!PageObject.mergeRotatedScaledPagec Csdddgdddg||dgg}|ddgd|dgdddgg}t||}|||dd|dd|dd|dd|dd|ddg|S)a. This is similar to mergePage, but the stream to be merged is translated and scaled by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float scale: The scaling factor :param float tx: The translation on X axis :param float ty: The translation on Y axis :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rrr)rr r) r/rrrrr r!r$rr3r3r4mergeScaledTranslatedPage s"   z$PageObject.mergeScaledTranslatedPagec Csdddgdddg||dgg}t|}t|t|dgt| t|dgdddgg}|ddgd|dgdddgg} t|| } t| |} ||| dd| dd| dd| dd| dd| ddg|S)a| This is similar to mergePage, but the stream to be merged is translated, rotated and scaled by appling a transformation matrix. :param PageObject page2: the page to be merged into this one. Should be an instance of :class:`PageObject`. :param float tx: The translation on X axis :param float ty: The translation on Y axis :param float rotation: The angle of the rotation, in degrees :param float scale: The scaling factor :param bool expand: Whether the page should be expanded to fit the dimensions of the page to be merged. rrrr) r/rrrrrr r!r"r$rr3r3r4 mergeRotatedScaledTranslatedPage5 s.     z+PageObject.mergeRotatedScaledTranslatedPagecCs>|}|dk r:t||j|}t||j}||td<dS)z Applies a transformation matrix to the page. :param tuple ctm: A 6-element tuple containing the operands of the transformation matrix. Nr)rrTrr:rr#)r/rrZ newContentr3r3r4addTransformationY szPageObject.addTransformationcCs||dd|ddgtt|j|t|j|t|j|t|j|g|_d|kr|d}t|t r|dd}n|d}tt|d|t|d|t|d|t|d|g}t|t r||t dt dt d<n||t dt d<dS)a  Scales a page by the given factors by appling a transformation matrix to its content and updating the page size. :param float sx: The scaling factor on horizontal axis. :param float sy: The scaling factor on vertical axis. rz/VPz/BBoxrrrN) r(r,rrYrrr r rr%r#r$)r/sxsyZviewportZbboxZ scaled_bboxr3r3r4rg s4   zPageObject.scalecCs|||dS)z Scales a page by the given factor by appling a transformation matrix to its content and updating the page size. :param float factor: The scaling factor (for both X and Y axis). N)r)r/Zfactorr3r3r4scaleBy szPageObject.scaleBycCsH|t|j|j}|t|j|j}|||dS)z Scales a page to the specified dimentions by appling a transformation matrix to its content and updating the page size. :param float width: The new width. :param float height: The new heigth. N)rrYr rr rr)r/rVrWr)r*r3r3r4scaleTo s  zPageObject.scaleTocCs:|}|dk r6t|ts&t||j}||td<dS)a Compresses the size of this page by joining all content streams and applying a FlateDecode filter. However, it is possible that this function will perform no action if content stream compression becomes "automatic" for some reason. Nr)rrrr:Z flateEncoder#)r/rr3r3r4compressContentStreams s   z!PageObject.compressContentStreamscCstd}|d}t|ts*t||j}|jD]\}}|tdkrh|d}t|trf||7}|d7}q0|tdkr~|d7}q0|tdkr|d7}|d}t|tr||d7}q0|tdkr|d }t|tr|d7}||7}q0|td kr0|dD]}t|tr||7}q|d7}q0|S) a Locate all text drawing commands, in the order they are provided in the content stream, and extract the text. This works well for some PDF files, but poorly for others, depending on the generator used. This will be refined in the future. Do not rely on the order of text coming out of this function, as it will change if this function is made more sophisticated. :return: a unicode string object. rfrrrrzT*rrrr)rr=rrr:rrrq)r/r"rr r!Z_textrr3r3r4 extractText s8                   zPageObject.extractTextrr3r)rz /BleedBox)rrz/TrimBoxz/ArtBox)NN)NNN)NNF)F)F)F)F)F)F)F)F)%rrErFrGr5rU staticmethodrrrrrrrrrrrrrrr#r%r&r'r(rr+r,r-r.rrYZcropBoxZbleedBoxZtrimBoxZartBoxr3r3r3r4rTsL  "       J        $  +    rTc@s>eZdZddZddZddZddZd d ZeeeZ d S) rcCsp||_g|_|}t|trRtd}|D]}|t|7}q*tt|}ntt|}||dS)Nrf) r:rr=rr%rrr"_ContentStream__parseContentStream)r/rr:rrr3r3r4r5 s zContentStream.__init__cCs|ddg}t|}|tdkst|dkr2q|dd|s^|tdks^|tdkrt|tjd}|tdkr|gkst | |}|j |td fq|j ||fg}q|td kr|td td fkr| d}qq| t|dqdS) NrrfrrrrTBI INLINE IMAGE%rr)rr rrisalpharZreadUntilRegexr#ZdelimiterPatternr@_readInlineImagerr6r^r)r/rr peekr!iir3r3r4Z__parseContentStream s*       z"ContentStream.__parseContentStreamc CsVt}t|}|dd|tdkr(q^t||j}t|}|ddt||j}|||<q|d}|ddtdksttd}|d}|tdkrB|d}|tdkr,|d} ||} d } | tj krd } | | 7} |d} q| td kr| r|ddqLn|dd|| 7}n|dd||7}q||7}q||d S) NrrIrrZIDrfEFTr )settingsr) r!r rrrr:r^r@r WHITESPACES) r/rr:tokrrrrZtok2Ztok3r1Zhas_q_whitespacer3r3r4r5, sB                  zContentStream._readInlineImagecCst}|jD]\}}|tdkr|tdt}|d|d||dd|td||d|tdn2|D]}||d|td q|t||td q |S) Nr2r1r:rrzID rZEIrr)rrrrrgetvalue)r/newdatar r!Zdicttextrr3r3r4_getData\ s   zContentStream._getDatacCs|tt|dSrF)r0rrrr3r3r4_setDatao szContentStream._setDataN) rrErFr5r0r5r?r@rHrr3r3r3r4r s  0rc@seZdZdZddZddZeddZeddZed dZ ed dZ ed dZ ed dZ ed dZ eddZeddZeddZdS)rba A class representing the basic document metadata provided in a PDF File. This class is accessible through :meth:`getDocumentInfo()` All text properties of the document metadata have *two* properties, eg. author and author_raw. The non-raw property will always return a ``TextStringObject``, making it ideal for a case where the metadata is being displayed. The raw property can sometimes return a ``ByteStringObject``, if PyPDF3 was unable to decode the string's text encoding; this requires additional safety in the caller and therefore is not as commonly accessed. cCst|dSrF)r!r5r;r3r3r4r5 szDocumentInformation.__init__cCs||d}t|tr|SdSrF)rprrq)r/rrcr3r3r4getText s  zDocumentInformation.getTextcCs |dSrrAr;r3r3r4rL rMzDocumentInformation.cCs |dSrrr;r3r3r4rL rMcCs |dSNz/AuthorrBr;r3r3r4rL rMcCs |dSrCrr;r3r3r4rL rMcCs |dSNz/SubjectrBr;r3r3r4rL rMcCs |dSrDrr;r3r3r4rL rMcCs |dSNz/CreatorrBr;r3r3r4rL rMcCs |dSrErr;r3r3r4rL rMcCs |dSNrrBr;r3r3r4rL rMcCs |dSrFrr;r3r3r4rL rMN)rrErFrGr5rArHrZ title_rawauthorZ author_rawsubjectZ subject_rawZcreatorZ creator_rawZproducerZ producer_rawr3r3r3r4rbu s          rbcCs>|dkrtdtdt|}|dd}td|dS)Nr~zinvalid size in convertToIntziz>qr)rrirrunpack)rrr3r3r4r s   ru(¿N^NuŠAdNVuÿú..¶Ðh>€/ u©þdSizTc Cstt|ttdd}ddl}t|}||j|d|}||||j|dkrt|st|td|} |dkrt dD]} t| d|} q| d|S)N rrruÿÿÿÿ2) rr_encryption_paddingrrr"rrrrh) rrrrrrmetadata_encryptrrrrr3r3r4_alg32 s      rNc Cst|||}t|ttdd}t||}|dkrtddD]>}d}tt|D]}|tt |||A7}qVt||}qB|S)NrJrrrrf) rrrrLrrrhr8rr) rrrrrrrrrHr3r3r4r s  rcCsZt|ttdd}t|}|}|dkrJtdD]}t|}q8|d|}|S)NrJrrK)rrrLrrrh)rrrrrrrr3r3r4r s  rcCs&t|dd|||}t|t}||fS)Nrr)rNrrrL)rrrrrrr3r3r4r$ s rcCst||||||}t}|t||j|} t|| } tddD]F} t d} tt |D] } | t t t || | A7} qdt| | } qL| t dd|fS)Nrrrfr) rNrr"rLrrrrrhrr8rr)rrrrrrrMrrrrrrrHr3r3r4r3 s   r)T)7rG __author____author_email__Z__maintainer__Z__maintainer_emailstringrrrr`r cStringIOriorrfrrrr)Zgenericr r r r rrrrrrZsetsrrrhashlibobjectrrKrrrrr!rTrdrrbrrLrNrrrrr3r3r3r4"s     $    @ Gy@  ,