HR-e 0ddlZddlZddlZddlZddlZddlmZddlmZm Z ddl Z ddl m Z ddlmZddlmZmZmZmZddlmZmZmZmZmZmZmZmZmZddlm Z m!Z!dd l"m#Z#dd l$m%Z%gd Z&Gd d Z'e'Z(dddddddZ) ddddddddddd Z* Gdde+Z,dZ-Gdd Z.e.Z/e.j0Z0e.j1Z1Gd!d"e.Z2Gd#d$e.e!Z3Gd%d&e.e!Z4Gd'd(e4Z5e5Z6Gd)d*e5Z7e7Z8dS)+N)suppress) Parameter signature)conf)_File)Header _BasicHeader_DelayedHeader _pad_length) _extract_number_free_space_check_get_array_mmap_is_int_is_pseudo_integer _pseudo_zero decode_asciifirstitersubclasses)_ErrList_Verify) lazyproperty)AstropyUserWarning)DELAYEDInvalidHDUException ExtensionHDUNonstandardExtHDUceZdZdS)_DelayedN)__name__ __module__ __qualname__8lib/python3.11/site-packages/astropy/io/fits/hdu/base.pyrr)sDr#ruint8int16int32int64float32float64) @r+r,r-r.r/r0) int8r%r&uint16r'uint32r(uint64r)r*ceZdZdZdS)rz A custom exception class used mainly to signal to _BaseHDU.__new__ that an HDU cannot possibly be considered valid, and must be assumed to be corrupted. N)rr r!__doc__r"r#r$rrMsr#rc|}|rttt|D]} |jds ||jvs'||r|}nsA#t$rYMt$rZ}tj d |ttj dtt}~Yd}~nd}~wwxYw|S)a Iterates through the subclasses of _BaseHDU and uses that class's match_header() method to determine which subclass to instantiate. It's important to be aware that the class hierarchy is traversed in a depth-last order. Each match_header() should identify an HDU type as uniquely as possible. Abstract types may choose to simply return False or raise NotImplementedError to be skipped. If any unexpected exceptions are raised while evaluating match_header(), the type is taken to be _CorruptedHDU. Used primarily by _BaseHDU._readfrom_internal and _BaseHDU._from_data to find an appropriate HDU class to use based on values in the header. zastropy.io.fits.zLAn exception occurred matching an HDU header to the appropriate HDU type: {}z%The HDU will be treated as corrupted.N)reversedlistrr startswith _hdu_registry match_headerNotImplementedError Exceptionwarningswarnformatr _CorruptedHDU)clsheaderklasscexcs r$_hdu_class_from_headerrHUs% E $~c223344  A L++,>??C--->>&))EE'       //5vc{{&  ;=O&  Ls$#A/A// C; CACCcteZdZdZeZdZdZdZe Z d+dZ fdZ e dZejd Ze d Zejd Ze d Zejd Ze dZejdZe dZe dZe dZedZedZedZed,dZed,dZd-dZedZe d.dZdZd,dZ dZ! d/d"Z"d#Z#d$Z$d%Z%d&Z&d'Z'd,d(Z(d)Z)d0d*Z*xZ+S)1_BaseHDUz2Base class for all HDU (header data unit) classes.TNc|t}||_d|_d|_d|_d|_d|_d|_d|_d|_ d|_ d|_ d|jvrd|jvr d|_ dSd|jvr d|_ dSdS)NFTDATASUMCHECKSUMdatasum) r_header _header_str_file_buffer_header_offset _data_offset _data_size_data_replaced_data_needs_rescale_new_output_checksum)selfdatarDargskwargss r$__init__z_BaseHDU.__init__s >XXF   "  $#(  %  $ $4<)G)G$-D ! ! ! 4< ' '$(D ! ! !( 'r#c |jdd}t|ttfr$|jd}|||_tj di|S)Nr]c|jb|jr]ttd}|rtj|j}|jd=|r%|dkr!|jdSdSdSdSdS)N getrefcountr])rS _data_loadedhasattrsysrcr]__dict___maybe_close_mmap)r\has_getrefcount data_refcounts r$r]z(_BaseHDU.__init_subclass__..datas:)d.?)&-c=&A&AO&C(+ (B(B  f-'7=A+=+= 4466666!*)))77+=+=r#r") rhget isinstancerpropertyfdeldeleterr]super__init_subclass__)rCr_ data_propr] __class__s r$rrz_BaseHDU.__init_subclass__s} L$$VT22 i,!9 : : /y~?U 7 7 7(!((..CH(uww(226222r#c|jSNrQr\s r$rDz_BaseHDU.headers |r#c||_dSrvrwr\values r$rDz_BaseHDU.headers  r#c\t|jd|jSNEXTNAME)strrQrl _default_namerxs r$namez _BaseHDU.names'4<##It/ABBCCCr#ct|tstdtjs|}d|jvr ||jd<dS|df|jd<dS)Nz!'name' attribute must be a stringr~zextension name)rmr TypeErrorrextension_name_case_sensitiveupperrQrzs r$rz _BaseHDU.namess%%% A?@@ @1 "KKMME  $ $&+DL # # #',.>&?DL # # #r#c8|jddS)NEXTVERrQrlrxs r$verz _BaseHDU.vers|!,,,r#ct|stdd|jvr ||jd<dS|df|jd<dS)Nz"'ver' attribute must be an integerrzextension valuerrrQrzs r$rz _BaseHDU.versWu~~ B@AA A t| # #%*DL " " "&+->%?DL " " "r#c8|jddS)NEXTLEVELrrrxs r$levelz_BaseHDU.levels| A...r#ct|stdd|jvr ||jd<dS|df|jd<dS)Nz$'level' attribute must be an integerrzextension levelrrzs r$rz_BaseHDU.levelsWu~~ DBCC C  % %',DL $ $ $(-/@'ADL $ $ $r#c|jdkpBd|jvo9|jddkp(|jddkod|jvo|jdduS)NPRIMARYXTENSIONIMAGEBINTABLEZIMAGET)rrQrxs r$is_imagez_BaseHDU.is_imageskyI%  $, &  Z(G3L, :7 DL07 X.$6 r#c0d|jvo |jtuS)Nr])rhr]rrxs r$rez_BaseHDU._data_loadeds&C49G+CCr#c"|jo|jduSrv)rer]rxs r$ _has_dataz_BaseHDU._has_datas :TYd%::r#c:|j|dSrv)r;addrChduclss r$ register_hduz_BaseHDU.register_hdus f%%%%%r#cP||jvr|j|dSdSrv)r;removers r$unregister_hduz_BaseHDU.unregister_hdus5 S& & &   $ $V , , , , , ' &r#ctrvr=rCrDs r$r<z_BaseHDU.match_header$s!!r#Fc $|j|f||d|S)a Creates a new HDU object of the appropriate type from a string containing the HDU's entire header and, optionally, its data. Note: When creating a new HDU from a string without a backing file object, the data of that HDU may be read-only. It depends on whether the underlying string was an immutable Python str/bytes object, or some kind of read-write memory buffer such as a `memoryview`. Parameters ---------- data : str, bytes, memoryview, ndarray A byte string containing the HDU's header and data. checksum : bool, optional Check the HDU's checksum and/or datasum. ignore_missing_end : bool, optional Ignore a missing end card in the header data. Note that without the end card the end of the header may be ambiguous and resulted in a corrupt HDU. In this case the assumption is that the first 2880 block that does not begin with valid FITS header data is the beginning of the data. **kwargs : optional May consist of additional keyword arguments specific to an HDU type--these correspond to keywords recognized by the constructors of different HDU classes such as `PrimaryHDU`, `ImageHDU`, or `BinTableHDU`. Any unrecognized keyword arguments are simply ignored. checksumignore_missing_end)_readfrom_internal)rCr]rrr_s r$ fromstringz_BaseHDU.fromstring(s7B&s%  #8J  NT   r#c t|tst|}|j|f||d|}||j|jzt j|S)a Read the HDU from a file. Normally an HDU should be opened with :func:`open` which reads the entire HDU list in a FITS file. But this method is still provided for symmetry with :func:`writeto`. Parameters ---------- fileobj : file-like Input FITS file. The file's seek pointer is assumed to be at the beginning of the HDU. checksum : bool If `True`, verifies that both ``DATASUM`` and ``CHECKSUM`` card values (when present in the HDU header) match the header and data of all HDU's in the file. ignore_missing_end : bool Do not issue an exception when opening a file that is missing an ``END`` card in the last header. r)rmrrseekrVrWosSEEK_SET)rCfileobjrrr_hdus r$readfromz_BaseHDU.readfromMsw0'5)) %GnnG$c$  &;M  QW    S%6 DDD r# exceptionc\ddlm}||g}|||||dS)aj Write the HDU to a new file. This is a convenience method to provide a user easier output interface if only one HDU needs to be written to a file. Parameters ---------- name : path-like or file-like Output FITS file. If the file object is already opened, it must be opened in a writeable mode. output_verify : str Output verification option. Must be one of ``"fix"``, ``"silentfix"``, ``"ignore"``, ``"warn"``, or ``"exception"``. May also be any combination of ``"fix"`` or ``"silentfix"`` with ``"+ignore"``, ``"+warn"``, or ``"+exception"`` (e.g. ``"fix+warn"``). See :ref:`astropy:verify` for more info. overwrite : bool, optional If ``True``, overwrite the output file if it exists. Raises an ``OSError`` if ``False`` and the output file exists. Default is ``False``. checksum : bool When `True` adds both ``DATASUM`` and ``CHECKSUM`` cards to the header of the HDU when written to the file. rHDUList overwriterN)hdulistrwriteto)r\r output_verifyrrrrs r$rz_BaseHDU.writetoqsE8 %$$$$$'4&//my8TTTTTr#c 8t||}|d||d|S)zg Instantiate the HDU object after guessing the HDU class from the FITS Header. r]rDr")rH)rCr]rDr_rEs r$ _from_dataz_BaseHDU._from_datas0 'sF33u8$v88888r#c 2d}d}d}ttr|i} tj\} }n<#t $r/|tj| }YnwxYw}} n tj ddn!#t$rtddwxYw|Dfd } tj | d d | d \} }tt| kr}nr}d}t| } t||}t|j} |} t"jd | jDvr|D]}|| jvr| |= |dt*|d | }nK#t$r>t|tr%tj| }|dt*|d | }nYnwxYw||_||_||_| |_|j}|t9|z|_t|jtr |`| |_|r/|dkr)t|t@r|!|S)z Provides the bulk of the internal implementation for readfrom and fromstring. For some special cases, supports using a header that was already created, and just using the input data for the actual array data. Nr)endcardr"ubyte)dtypebufferzThe provided object z does not contain an underlying memory buffer. fromstring() requires an object that supports the buffer interface such as bytes, buffer, memoryview, ndarray, etc. This restriction is to ensure that efficient access to the array/table data is possible.c3Kd}|tkr)|||zV||z }|tk'dSdSNr)len)nbytesidxr]s r$ block_iterz/_BaseHDU._readfrom_internal..block_itersWCD //"3v#56666v D //////r#TrLc3$K|] }|jV dSrv)kind).0xs r$ z._BaseHDU._readfrom_internal..s$(Q(QA(Q(Q(Q(Q(Q(Qr#rr)"rmrtellr fromfiler>rrnpndarrayr _from_blocksrrHrr`copyr VAR_KEYWORD parametersvaluesrrrSrTrUrVsizer rWrQrR _ValidHDU_verify_checksum_datasum)rCr]rDrrr_ hdu_buffer hdu_fileobj header_offset header_str data_offsetrsig new_kwargskeyrrs ` r$rz_BaseHDU._readfrom_internalsI   dE " "2 *~ $  S *6)>t)D)D&J SSS IIm,,,#_T?Q;QRRRFFF SK))++KK  2WT:::::   Q4QQQ ~&&&&& &,%8b.@*@$&&" Ft99s:..!%J "! Mj//K %S&11 %%[[]]  (Q(Q9N9N9P9P(Q(Q(Q Q Q ( (cn,,"3 #@76@@Z@@CC   &,// *:66cDwvDDDD     *&x D 1 11 ck< 0 0 ) (CO  +H,,C1K1K,  ( ( * * * s0A 6BB B88C-F>>AHHct|tjr|f}|jrt j|||j|S|jr|j|||SdS)zb Return raw array from either the HDU's memory buffer or underlying file. )rroffset)rrshapeN)rmnumbersIntegralrTrrrS readarray)r\rcoders r$ _get_raw_dataz_BaseHDU._get_raw_datasq eW- . . HE < :e4 VTTT T Z :''vT'OO O4r#cX|||dSrv)!_update_pseudo_int_scale_keywords_update_checksum)r\rinplaces r$ _prewritetoz_BaseHDU._prewriteto+s0 ..000 h'''''r#c|jr|jrt|jjrd|jvr|jdddnBd|jvr|jdddn|jdd|jdt|jjddSdSdSdS)zt If the data is signed int 8, unsigned int 16, 32, or 64, add BSCALE/BZERO cards to header. TFIELDSBSCALEr)afterGCOUNTBZERON)r _standardrr]rrQsetrrxs r$rz*_BaseHDU._update_pseudo_int_scale_keywords1s > Udn U1CDIO1T1T UDL((   1I >>>>T\))   1H ====   1--- L  Wl49?&C&C8  T T T T T U U U U U Ur#rOrNcT|jjp|j}|dkr&||jvr|j|=||jvr |j|=dSdS|s)|js"|rYd|jvsd|jvs|jr|js;|dkr||dS|r|||dSdSdSdS)a!Update the 'CHECKSUM' and 'DATASUM' keywords in the header (or keywords with equivalent semantics given by the ``checksum_keyword`` and ``datasum_keyword`` arguments--see for example ``CompImageHDU`` for an example of why this might need to be overridden). rrOrNrPdatasum_keyword)checksum_keywordrN)rQ _modifiedrerZ_checksum_valid_datasum_valid add_datasum add_checksum)r\rrrmodifieds r$rz_BaseHDU._update_checksumAs(<)>T-> x  4<//L!12$,..L111/.  y    dl22  44/5.5 9$$   AAAAA !!%5"!  54  r#c|jrY|jrTt|jjr=dD]<}t t 5|j|=dddn #1swxYwY7dSdSdSdS)N)rr)rrrr]rrKeyErrorrQr\keywords r$ _postwritetoz_BaseHDU._postwritetogs > .dn .1CDIO1T1T .. . .h''.. W-............... . . . . . . . .s AA A cpd}ttt5|}dddn #1swxYwY|j| ||z }n8#ttf$r$t t|j}YnwxYw||fSr)rAttributeErrorOSErrorrrQtofilerrr\rrrs r$ _writeheaderz_BaseHDU._writeheaderos ng . . $ $\\^^F $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ G$$$ *<<>>F*DD( * * *s4<(())DDD *t|s!>AA$A<<2B10B1cd}| |}n#ttf$rd}YnwxYw|js|jr|j|||z }|dkrdt|dkrQt||j z}| | d|t|z }n|| |z }|||fS)Nrascii)flushrrr rerYr]_writedata_internalr _padding_bytewriteencoder_writedata_direct_copy)r\rrrpaddings r$ _writedataz_BaseHDU._writedata}s   \\^^FF(   FFF    9 8 9y$00999axxK--11%d++d.@@  gnnW55666G $ D//88 8D  t|s-AAch||j|jj|jjzS)a# The beginning and end of most _writedata() implementations are the same, but the details of writing the data array itself can vary between HDU types, so that should be implemented in this method. Should return the size in bytes of the data written. ) writearrayr]ritemsize)r\rs r$rz_BaseHDU._writedata_internals. 49%%%y~ 222r#c||jd|j}||||jSdS)aCopies the data directly from one file/buffer to the new file. For now this is handled by loading the raw data from the existing data (including any padding) via a memory map or from an already in-memory buffer and using Numpy's existing file-writing facilities to write to the new file. If this proves too slow a more direct approach may be used. rNr)rrWrVrr)r\rraws r$rz_BaseHDU._writedata_direct_copysF  '4;LMM ?   s # # #: 1r#c tj|jj}n#t t f$rd}YnwxYwt||5||||ddddS#1swxYwYdSrv) rpathdirnamerSrrrr _writeto_internal)r\rrrrs r$_writetoz_BaseHDU._writetos googm&899GG *   GGG tW - - ; ;  " "7GT : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;s!),AAA::A>A>c|r|jrN||\}}||\}}|jr||_||_||_dS|j}|j|jz } |j} |j} |jjr8|j |||\}} || z} nq|ro|j || }| |j | | } |j rv|jn|s|jrd} nt!|j} | | nO|j |j||\} } n|r||} ||_| |_| |_d|_dS)NF)rZr rrUrVrWrQrrSrrrreadrer]rXrrr) r\rrrr_r data_sizehdrlochdrsizedatlocdatsize array_mmaps r$rz_BaseHDU._writeto_internals $) #0099 M1%)__W%=%= "Ky ,&3#$/!"+ F$#d&99"/ < ! $ JOOF # # #"//88OFG g%FF  $ JOOF # # #\\^^F MM$*//'22 3 3 3\\^^F   ;y$<4.<"&JJ!0!;!;J)$$&&&&JOOD$5666&*oog&>&>OFG  ;11'::G$"!#r#cP|r|jrt|j|`dSdSdSdSrv)rerr])r\closeds r$_closez_BaseHDU._close sH  d' ODI,F,F,R     ,R,Rr#)NN)FFrFF)NFF)rOrN)T),rr r!r6rr;rrrr rQr`rrrnrDsetterrrrrrer classmethodrrr<rrrrrrrrrrr rrrr rr, __classcell__rts@r$rJrJs<<CEEMIMMnG))))233333BX ]]DDXD  [@@[@--X- Z@@Z@//X/ \BB\B   X  DDXD;;X;&&[&--[-""["" " " [" H!!![!FUUUUB99[9CHzzz[zx   &(((( UUU"FO$$$$L...      D 3 3 3*;;;;?$?$?$Br#rJc4eZdZdZedZdZdZdS)rBaQ A Corrupted HDU class. This class is used when one or more mandatory `Card`s are corrupted (unparsable), such as the ``BITPIX``, ``NAXIS``, or ``END`` cards. A corrupted HDU usually means that the data size cannot be calculated or the ``END`` card is not found. In the case of a missing ``END`` card, the `Header` may also contain the binary data .. note:: In future, it may be possible to decipher where the last block of the `Header` ends, but this task may be difficult when the extension is a `TableHDU` containing ASCII data. cp|jt|j|jz S|jj|jz SzE Returns the size (in bytes) of the HDU's data part. rTrrVrSrrxs r$rz_CorruptedHDU.size.s6 < #t|$$t'88 8z!222r#c |j|jdfS)N CorruptedHDU)rrrxs r$_summaryz_CorruptedHDU._summary:s 48^44r#cdSrvr"rxs r$verifyz_CorruptedHDU.verify=s r#N)rr r!r6rnrr8r:r"r#r$rBrBsW  3 3X 3555     r#rBcleZdZdZdZedZedZdZ dZ e dZ d d Z d S) _NonstandardHDUax A Non-standard HDU class. This class is used for a Primary HDU when the ``SIMPLE`` Card has a value of `False`. A non-standard HDU comes from a file that resembles a FITS file but departs from the standards in some significant way. One example would be files where the numbers are in the DEC VAX internal storage format rather than the standard FITS most significant byte first. The header for this HDU should be valid. The data for this HDU is read from the file as a byte stream that begins at the first byte after the header ``END`` card and continues until the end of the file. FcD|jd}|jdko|jduS)zt Matches any HDU that has the 'SIMPLE' keyword but is not a standard Primary or Groups HDU. rSIMPLEF)cardsrr{)rCrDcards r$r<z_NonstandardHDU.match_headerRs(|A|x'?DJ%,??r#cp|jt|j|jz S|jj|jz Sr4r5rxs r$rz_NonstandardHDU.size\s6 < #t|$$t'88 8z!222r#cd}d}| |}n#t$rd}YnwxYw|jB||j|t |j}||fS)z Differs from the base class :class:`_writedata` in that it doesn't automatically add padding, and treats the data as a string of raw bytes instead of an array. r)rrr r]rrr s r$rz_NonstandardHDU._writedatafs   \\^^FF   FFF  9 MM$) $ $ $ MMOOOty>>Dt|s / >>cF|j|jdt|jfS)NNonstandardHDU)rrrrQrxs r$r8z_NonstandardHDU._summary~s  48%5s4<7H7HIIr#cD||jd|jSz' Return the file data. rrrrVrxs r$r]z_NonstandardHDU.data! !!$)Wd6GHHHr#r@ctgd}|jjD]*}|||+|S)NCardunit)rrQr?append_verify)r\optionerrsr@s r$rNz_NonstandardHDU._verifysP(((L& . .D KK V,, - - - - r#Nr@)rr r!r6rr/r<rnrrr8rr]rNr"r#r$r<r<As  I@@[@33X30JJJII\I r#r<ceZdZdZdfd ZedZedZdZ dZ dZ dd Z d Z d d Z d!dZdZdZdZdZdZd"dZd#dZd#dZgdZgdZdZdZxZS)$rz: Base class for all HDUs which are not corrupted. Nc t|||+t|ttfst dd|_d|_d|_d|_ |||_ | ||_ dSdS)Nrzheader must be a Header object) rqr`rmrr ValueError _checksumr_datasumrrr)r\r]rDrrr_rts r$r`z_ValidHDU.__init__s d6222  j&,9O&P&P =>> ># "  DI ?DHHH ?r#cHt|dvS)a Matches any HDU that is not recognized as having either the SIMPLE or XTENSION keyword in its header's first card, but is nonetheless not corrupted. TODO: Maybe it would make more sense to use _NonstandardHDU in this case? Not sure... )r>r)rkeysrs r$r<z_ValidHDU.match_headers V[[]]##+AAAr#c|jjS)zA Size (in bytes) of the data portion of the HDU. )rQr$rxs r$rz_ValidHDU.sizes |%%r#ct}||d||dzS)zh Calculates and returns the number of bytes that this HDU will write to a file. r)rr r)r\fs r$ filebytesz_ValidHDU.filebytess< GG  ##A&););A)>>>r#ct|dr-|jr&|j|jj|j|j|jdSdS)a Returns a dictionary detailing information about the locations of this HDU within any associated file. The values are only valid after a read or write of the associated file with no intervening changes to the `HDUList`. Returns ------- dict or None The dictionary details information about the locations of this HDU within an associated file. Returns `None` when the HDU is not associated with a file. Dictionary contents: ========== ================================================ Key Value ========== ================================================ file File object associated with the HDU filemode Mode in which the file was opened (readonly, copyonwrite, update, append, ostream) hdrLoc Starting byte location of header in file datLoc Starting byte location of data block in file datSpan Data size including padding ========== ================================================ rS)filefilemodehdrLocdatLocdatSpanN)rfrSmoderUrVrWrxs r$fileinfoz_ValidHDU.fileinfosR6 4 ! ! dj   JO-+?  4r#c|j|j}nd}|||jS)zJ Make a copy of the HDU, both header and data are copied. Nr)r]rrtrQ)r\r]s r$rz_ValidHDU.copysH 9 9>>##DDD~~4 0A0A0C0C~DDDr#r@c tgd}tjt|tr d}|j}nd}d}||dd||||ddfd d |||d d d d|||jd d}|dkrtd|dzD]L}d t|d z z}|||dt|j|d||M|jD]}| d rt|dkr t|dd} | dks| |krtV#t$rKd||} ||fd} |||| | dYwxYwd|jvrZt|jdts:d} d} |jfd} |||| | | |jjD]*} || |+|S)NrJrKrr>TrBITPIXrc8t|o |Srvr)vis_valids r$z#_ValidHDU._verify.. sGAJJ$>88A;;r#r+NAXISrdc@t|od|cxkodkncS)Nririrjs r$rlz#_ValidHDU._verify.. s%71::#?!q----C----r#ic,t|o|dkSrriros r$rlz#_ValidHDU._verify..swqzz4a1fr#)defaultz3NAXISj keyword out of range ('{}' when NAXIS == {})c|j|=dSrvrwrs r$fixz_ValidHDU._verify..fix)s $ W 5 5 5r#zDeleted.)rOerr_textrufix_textr~z-The EXTNAME keyword must have a string value.z0Converted the EXTNAME keyword to a string value.c6t|d|d<dSr})r)rDs r$ruz_ValidHDU._verify..fix;s(+F9,=(>(>F9%%%r#rvrwru)r BITPIX2DTYPE __contains__rmr _extension req_cardsrQrlrangerr r:rintrTrArM run_optionr?rN)r\rOrPfirstkeyfirstvalnaxisaxrrnumberrvrurwr@rks @r$rNz_ValidHDU._verifys(((, dL ) ) !HHHHH xD(FDAAA  a????FD     Q@@!VT      !,, 4<<Auqy))  BF +55#DL$5qAAA  <  %%g..3w< 10`` this will check that the keyword's index is greater than 10. test : callable This should be a callable (generally a function) that is passed the value of the given keyword and returns `True` or `False`. This can be used to validate the value associated with the given keyword. fix_value : str, int, float, complex, bool, None A valid value for a FITS keyword to to use if the given ``test`` fails to replace an invalid value. In other words, this provides a default value to use as a replacement if the keyword's current value is invalid. If `None`, there is no replacement value and the keyword is unfixable. option : str Output verification option. Must be one of ``"fix"``, ``"silentfix"``, ``"ignore"``, ``"warn"``, or ``"exception"``. May also be any combination of ``"fix"`` or ``"silentfix"`` with ``"+ignore"``, ``+warn``, or ``+exception" (e.g. ``"fix+warn"``). See :ref:`astropy:verify` for more info. errlist : list A list of validation errors already found in the FITS file; this is used primarily for the validation system to collect errors across multiple HDUs and multiple calls to `req_cards`. Notes ----- If ``pos=None``, the card can be anywhere in the header. If the card does not exist, the new card will have the ``fix_value`` as its value when created. Also check the card's value by using the ``test`` argument. Nrc|kSrvr")r insert_poss r$rlz%_ValidHDU.req_cards..s AOr#'z' card does not exist.zFixed by inserting a new 'z' card.c<|j||dSrv)rQinsert)r\rr@s r$ruz _ValidHDU.req_cards..fixs L'' D99999r#)rvrwrufixablez ' card at the wrong place (card z).z,Fixed by moving it to the right place (card cp|jj|}|j|=|j||dSrv)rQr?r)r\indexrr@s r$ruz _ValidHDU.req_cards..fixs9#|1%8 L/ ++J=====r#ryz' card has invalid value 'z'.zFixed by setting a new value 'c|j|<dSrvrw)r\rval fix_values r$ruz _ValidHDU.req_cards..fixs4=DL111r#)rQrrTrrrMr)r\rpostestrrOerrlistrPrurrrvrwr@rrs ` @r$r}z_ValidHDU.req_cardsLsd L&&w//EE   EEE 4'&&*  3<< ,J++++C =:7:::HDGDDDH : +!jt:::: KK%%#      s5zzU7UUEUUUHUzUUU"&Uz>>>> KK"Xc( l7+tCyyM7MMcMMMHM MMMH>%)7 >>>>>>KK"%-%- #$+ ( s # 22rNc|}|d|}t||f|j|<|S)a Add the ``DATASUM`` card to this HDU with the value set to the checksum calculated for the data. Parameters ---------- when : str, optional Comment string for the card that by default represents the time when the checksum was calculated datasum_keyword : str, optional The name of the header keyword to store the datasum value in; this is typically 'DATASUM' per convention, but there exist use cases in which a different keyword should be used Returns ------- checksum : int The calculated datasum Notes ----- For testing purposes, provide a ``when`` argument to enable the comment value in the card to remain consistent. This will enable the generation of a ``CHECKSUM`` card with a consistent value. Nzdata unit checksum updated )_calculate_datasum_get_timestamprrQ)r\whenrcss r$rz_ValidHDU.add_datasumsN6 $ $ & & <H1D1D1F1FHHD),R$ _% r#FrOc^|s|||}n|}|d|}||jvr|j|d||n|j|d||||}||j|<dS)a Add the ``CHECKSUM`` and ``DATASUM`` cards to this HDU with the values set to the checksum calculated for the HDU and the data respectively. The addition of the ``DATASUM`` card may be overridden. Parameters ---------- when : str, optional comment string for the cards; by default the comments will represent the time when the checksum was calculated override_datasum : bool, optional add the ``CHECKSUM`` card only checksum_keyword : str, optional The name of the header keyword to store the checksum value in; this is typically 'CHECKSUM' per convention, but there exist use cases in which a different keyword should be used datasum_keyword : str, optional See ``checksum_keyword`` Notes ----- For testing purposes, first call `add_datasum` with a ``when`` argument, then call `add_checksum` with a ``when`` argument and ``override_datasum`` set to `True`. This will provide consistent comments for both cards and enable the generation of a ``CHECKSUM`` card with a consistent value. rNzHDU checksum updated 0000000000000000)before)r)rrrrQr_calculate_checksum)r\roverride_datasumrrdata_cscsums r$rz_ValidHDU.add_checksumsH  0&&t_&MMGG--//G <B4+>+>+@+@BBD dl * * L  -xo  V V V V L  -x > > >''BR'SS)- %&&&r#cd|jvr6|}|t|jdkrdSdSdS)a. Verify that the value in the ``DATASUM`` keyword matches the value calculated for the ``DATASUM`` of the current HDU data. Returns ------- valid : int - 0 - failure - 1 - success - 2 - no ``DATASUM`` keyword present rNrrrd)rQrr)r\rPs r$verify_datasumz_ValidHDU.verify_datasum+sM  $ $--//G#dl956666qq1r#cd|jvrJd|jvr|}nd}||}||jdkrdSdSdS)a! Verify that the value in the ``CHECKSUM`` keyword matches the value calculated for the current HDU CHECKSUM. Returns ------- valid : int - 0 - failure - 1 - success - 2 - no ``CHECKSUM`` keyword present rOrNrrrd)rQrr)r\rPrs r$verify_checksumz_ValidHDU.verify_checksumAsl  % %DL((1133//88H4< 333qq1r#cd|jvr\|jd|_||_|js*t jd|j|jfdtd|jvr^|jd|_ | |_ |j s.t jd|j|jfdtdSdSdS)z Verify the checksum/datasum values if the cards exist in the header. Simply displays warnings if either the checksum or datasum don't match. rOz%Checksum verification failed for HDU z. rNz$Datasum verification failed for HDU N) rQrUrrr?r@rrrrVrrrxs r$rz"_ValidHDU._verify_checksum_datasum[s  % %!\*5DN#'#7#7#9#9D '  TDItx;PTTT&  $ $ L3DM"&"5"5"7"7D &  S49dh:OSSS& % $  r#crtjddS)z Return the current timestamp in ISO 8601 format, with microseconds stripped off. Ex.: 2007-05-30T19:05:11 N)datetimenow isoformatrxs r$rz_ValidHDU._get_timestamprs. $$&&00223B377r#c|jsC|jdkr6||jd|j}||SdS|j-||jdSdS)zJ Calculate the value for the ``DATASUM`` card in the HDU. rr)rerrrWrV_compute_checksumr]view)r\raw_datas r$rz_ValidHDU._calculate_datasum{s  y1}}--OWd.?--h777q Y "))$)..*A*ABB B1r#c |j|}d|j|<|jd}|t j|d|}||}||j|<|S)zJ Calculate the value of the ``CHECKSUM`` card in the HDU. rutf8rr)rQtostringrrr frombuffer _char_encode)r\rPr old_checksumsrs r$rz_ValidHDU._calculate_checksums|$45 )1 %& L ! ! # # * *6 2 2 # #BM!7$C$C$CW M M   rc " "*6 %&r#rcd}tj|}tdt||D]C}t |t||z }|||||z|}D|S)a6 Compute the ones-complement checksum of a sequence of bytes. Parameters ---------- data a memory region to checksum sum32 incremental checksum value from another region Returns ------- ones complement checksum i@ r)rr3r~rmin_compute_hdu_checksum)r\r]sum32blocklenilengths r$rz_ValidHDU._compute_checksums}  %  q#d))X.. L LA3t99q=11F..tAF N/CUKKEE r#ctjd}tjd}tjd}|jdzr|d}|dd}ntjd}|d}||z }||z}|tj|dddtj z }|tj|d ddtj z }|jdzdzr |||zz }n|||zz }||z } ||z } | s| r||z| z}||z| z}||z } ||z } | | ||z|zS) a Translated from FITS Checksum Proposal by Seaman, Pence, and Rots. Use uint32 literals as a hedge against type promotion to int64. This code should only be called with blocks of 2880 bytes Longer blocks result in non-standard checksums with carry overflow Historically, this code *was* called with larger blocks and for that reason still needs to be for backward compatibility. r+r,irdNrz>u2rr)rr3rrrreducer4) r\r]ru8u16uFFFFlasthilohicarrylocarrys r$rz_ValidHDU._compute_hdu_checksumsvYq\\imm &!! ;? 8D9DD9Q<?r.[\]^_`c"|dztdz}|dz}tj||z|||gd}d}|rSd}|jD]G}dD]B}|||ks||dz|kr%||xxdz cc<||dzxxdzcc<d}CH|S|S) z' Encode a single byte. 0r'rTF)rrdr)ordrarray_EXCLUDE)r\bytequotient remainderchcheckrjs r$ _encode_bytez_ValidHDU._encode_bytes19s3xx'1H X"Xx B'    %E] % %%%A!uzzRAY!^^1 1q5 Q $ % % r#ctj|}tjdd}tjdd}tdD]S}||j|zd|z dzz }||}tdD]}|||d|z|z<TtdD]}||dzdz||<t |S) a  Encodes the checksum ``value`` using the algorithm described in SPR section A.7.2 and returns it as a 16 character string. Parameters ---------- value a checksum Returns ------- ascii encoded checksum )r,rrrrpr+r,)rr3zerosr~_MASKrrtobytes)r\r{ascrrrrrs r$rz_ValidHDU._char_encodes %  huF+++f---q ' 'ADJqM)A{;D""4((B1XX ' '!#AAEAI 'r * *AAFb=)E!HHEMMOO,,,r#)NNNNrQ)NrN)NFrOrN)rO)r)rr r!r6r`r/r<rnrr\rdrrNr}rrrrrrrrrrrrrrr0r1s@r$rrs* B B[ B&&X& ???$$$LEEEPPPPhCCCJ!!!!J#! 5.5.5.5.n,4.888(*.) ) ) ) Z = < .GGAJJ,A16r#rrc,t|o|dkS)Nrriros r$rlz&ExtensionHDU._verify..Jrr#r)rqrNrQrlr})r\rOrPrrts r$rNzExtensionHDU._verifyAswwf--   !,,  eai!B!BAvt     eai!B!BAvt    r#r-rQ) rr r!r6r|r/r<rrNr0r1s@r$rr"sJ""[" U U U U          r#rcHeZdZdZdZedZdZedZ dS)ra A Non-standard Extension HDU class. This class is used for an Extension HDU when the ``XTENSION`` `Card` has a non-standard value. In this case, Astropy can figure out how big the data is but not what it is. The data for this HDU is read from the file as a byte stream that begins at the first byte after the header ``END`` card and continues until the beginning of the next header or the end of the file. Fc|jd}|j}t|tr|}d}|jdko||vS)zh Matches any extension HDU that is not one of the standard extension HDU types. r)rTABLErA3DTABLEr)r?r{rmrrstripr)rCrDr@xtensionstandard_xtensionss r$r<zNonstandardExtHDU.match_headercsZ |A: h $ $ )((HH|z)Ph>P.PPr#czt|jj}|j|jdt |j|fS)Nr)tupler]rrrrrQ)r\axess r$r8zNonstandardExtHDU._summaryus3TY_%% 48%8#dl:K:KTRRr#cD||jd|jSrFrGrxs r$r]zNonstandardExtHDU.datayrHr#N) rr r!r6rr/r<r8rr]r"r#r$rrUss  IQQ[Q"SSSII\IIIr#r)9rrrrgr? contextlibrinspectrrnumpyrastropy.io.fitsrastropy.io.fits.filerastropy.io.fits.headerrr r r astropy.io.fits.utilr r rrrrrrrastropy.io.fits.verifyrr astropy.utilsrastropy.utils.exceptionsr__all__rrrz DTYPE2BITPIXr>rrHrJ_AllHDUrrrBr<rr _ExtensionHDUr_NonstandardExtHDUr"r#r$r s (((((((( &&&&&&TTTTTTTTTTTT                      54444444&&&&&&777777            (**    4        )---dH H H H H H H H Z  $ (! ! ! ! ! H! ! ! HNNNNNhNNNbM -M -M -M -M -'M -M -M -`+++++9+++` )I)I)I)I)I )I)I)IZ'r#