
    l0jB                       d Z ddlmZ g dZddlmZmZ ddlZerddlmZm	Z	 ddl
mZmZmZ 	 ddlZ	 dAdddBdZdddCdZn# e$ r 	 dAdddBdZdddCdZY nw xY w	 ddlZ	 dAdddBdZdddCdZn# e$ r 	 dAdddBdZdddCdZY nw xY w	 ddlmZ 	 dAdddBdZdddCdZn# e$ r 	 dAdddBdZdddCdZY nw xY wdddDdZe	 	 dEdddFd&            Ze	 dEdddGd(            Z	 	 dEdddHd*ZedFd+            ZedGd,            Z	 	 dEdddHd-Zedg d.dId2            Zedg d.dJd3            Zedg d.dKd4            Zdg d.dLd5Z	 dMdddNd:Zd dd;dOd=ZdPd@ZdS )Qa   Fallback imagecodecs codecs.

This module provides alternative, pure Python and NumPy implementations of
some functions of the `imagecodecs`_ package. The functions may raise
`NotImplementedError`.

.. _imagecodecs: https://github.com/cgohlke/imagecodecs

    )annotations)bitorder_decodedelta_decodedelta_encodefloat24_decodelzma_decodelzma_encodepackbits_decodepackints_decodepackints_encodezlib_decodezlib_encodezstd_decodezstd_encode)TYPE_CHECKINGoverloadN)AnyLiteral)	ArrayLike	DTypeLikeNDArrayoutlevel
int | Nonedatabytes | NDArray[Any]r   r   returnbytesc                  ~~t          | t          j                  r|                                 } t	          j        |           S )zCompress LZMA.

        Parameters:
            data: Data to compress.
            level: Compression level (currently unused).
            out: Output buffer (currently unused).

        )
isinstancenumpyndarraytobyteslzmacompressr   r   r   s      X/home/wildlama/miniconda3/envs/lam/lib/python3.11/site-packages/tifffile/_imagecodecs.pyr	   r	   H   s:     3dEM** 	"<<>>D}T"""    c              ,    ~t          j        |           S )zDecompress LZMA.

        Parameters:
            data: Compressed data.
            out: Output buffer (currently unused).

        )r%   
decompressr   r   s     r(   r   r   \        t$$$r)   c                  ~ ~~ddl }dS Raise ImportError.r   Nr)   r%   )r   r   r   r%   s       r(   r	   r	   i        %sr)   c                  ~ ~ddl }dS r/   r1   )r   r   r%   s      r(   r   r   v       #sr)   c                  ~t          | t          j                  r|                                 } t	          j        | |dn|          S )zCompress Zlib DEFLATE.

        Parameters:
            data: Data to compress.
            level: Compression level (0-9, default 6).
            out: Output buffer (currently unused).

        N   )r!   r"   r#   r$   zlibr&   r'   s      r(   r   r      sB     dEM** 	"<<>>D}T115AAAr)   c              ,    ~t          j        |           S )zDecompress Zlib DEFLATE.

        Parameters:
            data: Compressed data.
            out: Output buffer (currently unused).

        )r7   r+   r,   s     r(   r   r      r-   r)   c                  ~ ~~ddl }dS r/   r7   )r   r   r   r7   s       r(   r   r      r2   r)   c                  ~ ~ddl }dS r/   r:   )r   r   r7   s      r(   r   r      r4   r)   zstdc                  ~t          | t          j                  r|                                 } t	          j        | |          S )zCompress ZSTD.

        Parameters:
            data: Data to compress.
            level: Compression level.
            out: Output buffer (currently unused).

        )r   )r!   r"   r#   r$   r=   r&   r'   s      r(   r   r      s=     dEM** 	"<<>>D}T////r)   c              ,    ~t          j        |           S )zDecompress ZSTD.

        Parameters:
            data: Compressed data.
            out: Output buffer (currently unused).

        )r=   r+   r,   s     r(   r   r      r-   r)   c                  ~ ~~ddl m} dS r0   r   r<   r)   compressionr=   )r   r   r   r=   s       r(   r   r      s"     %$$$$$$sr)   c                  ~ ~ddl m} dS rA   rB   )r   r   r=   s      r(   r   r      s    #$$$$$$sr)   encodedc              4   ~g }|j         }d}	 	 t          | ||dz                      dz   }|dz  }|dk    r" || ||dz            d|z
  z             |dz  }n!|dk     r || |||z                       ||z  }l# t          $ r Y nw xY wt          |          S )a  Decompress PackBits encoded byte string.

    Parameters:
        encoded: PackBits encoded byte string.
        out: Output buffer (currently unused).

    Returns:
        Decompressed byte string.

    Examples:
        >>> packbits_decode(b'\x80\x80')  # NOP
        b''
        >>> packbits_decode(b'\x02123')
        b'123'
        >>> packbits_decode(
        ...     b'\xfe\xaa\x02\x80\x00\x2a\xfd\xaa\x03\x80\x00\x2a\x22\xf7\xaa'
        ... )[:-5]
        b'\xaa\xaa\xaa\x80\x00*\xaa\xaa\xaa\xaa\x80\x00*"\xaa\xaa\xaa\xaa\xaa'

    r   T      i  )extendord	TypeErrorr   )rE   r   
out_extendins        r(   r
   r
      s    * 	
CJ	A
	GAAI&''!+AFA3ww
71q1u9-q9:::QS
71q1u9-...Q
	    ::s   A-A; ;
BBrG   axisintdistbytes | bytearrayc                  d S N r   rP   rR   r   s       r(   r   r     s	     Cr)   NDArray[Any]c                  d S rU   rV   rW   s       r(   r   r   &  	     3r)    bytes | bytearray | NDArray[Any]c              B   ~|dk    rd|d}t          |          t          | t          t          f          rdt	          j        | t          j                  } t	          j        | d          }t	          j        |d| d                   	                                S | j
        }|j        dk    r$|                     |j         d|j                   } t	          j        | |          }t          d	          g| j        z  }d||<   t	          j        |d| t#          |                   |          }| j
        j        sB|                    d
          }|                    |j
                                                  }|j        dk    r|                    |          S |S )a  Encode Delta.

    Encode differences between consecutive samples along axis.

    Parameters:
        data: Data to encode.
        axis: Axis along which to compute differences (default -1).
        dist: Distance between samples (only dist=1 is supported).
        out: Output buffer (currently unused).

    Returns:
        Encoded data.
        Returns bytes for bytes/bytearray input, numpy array otherwise.

    rG   zdelta_encode with dist=# requires the 'imagecodecs' packagedtyper   )rP   fuNT)inplace)NotImplementedErrorr!   r   	bytearrayr"   
frombufferuint8diffinsertr$   r_   kindview	byteorderitemsizeslicendimtupleisnativebyteswapnewbyteorder)r   rP   rR   r   msgrg   r_   keys           r(   r   r   ,  s   . 	qyyM4MMM!#&&&$	*++ 8EK888z$Q'''|D!T!W--55777JEzSyyEO>>en>>??:d&&&D#Dkk]TY6CCI<aeCjj!1===D: 4}}T}**yy002233zSyyKr)   c                  d S rU   rV   rW   s       r(   r   r   [  s	     Cr)   c                  d S rU   rV   rW   s       r(   r   r   a  rZ   r)   c                 |dk    rd|d}t          |          ||j        j        sd}t          | t          t
          f          rTt          j        | t          j                  } t          j	        | dt          j        |          
                                S | j        j        dk    r| j        j        sd	| j        d}t          |          |                     | j        j         d
| j        j                   }t          j	        |||j                  }|                    | j                  S t          j	        | || j        |          S )a  Decode Delta.

    Decode delta-encoded data by computing cumulative sum along axis.

    Parameters:
        data: Encoded data.
        axis: Axis along which to compute cumulative sum (default -1).
        dist: Distance between samples (only dist=1 is supported).
        out: Output buffer for results.

    Returns:
        Decoded data.
        Returns bytes for bytes/bytearray input, numpy array otherwise.

    rG   zdelta_decode with dist=r]   Nr^   r   )rP   r_   r   r`   zdelta_decode with ra   )rP   r_   )rc   flags	writeabler!   r   rd   r"   re   rf   cumsumr$   r_   ri   rp   rj   rk   rl   )r   rP   rR   r   rs   rj   s         r(   r   r   g  s]   . qyyM4MMM!#&&&
sy2$	*++ EK888|q
 
 

'))	 z#z" 	+5TZ 5 5 5  &c***yyDJ0HH4:3FHHII|Dt4:>>>yy$$$<4tzs   r)   )r   	_bitorderrd   r{   	list[Any]c                  d S rU   rV   r   r   r{   s      r(   r   r     s	     r)   c                  d S rU   rV   r~   s      r(   r   r     s	     Cr)   c                  d S rU   rV   r~   s      r(   r   r     s	     3r)   c                 ~|sN|                     d           |                     t          j        |d         t          j                             t	          | t
          t          f          r|                     |d                   S 	 |                     d          }t          j	        |d         ||           n$# t          $ r}d}t          |          |d}~ww xY w| S )	a  Reverse bits in each byte of bytes or numpy array.

    Decode data where pixels with lower column values are stored in the
    lower-order bits of the bytes (TIFF FillOrder is LSB2MSB).

    Parameters:
        data:
            Data to be bit-reversed.
            If bytes type, a new bit-reversed bytes is returned.
            NumPy arrays are bit-reversed in-place.
        out:
            Output buffer (currently unused).
        _bitorder:
            Internal caching parameter (not for public use).

    Examples:
        >>> bitorder_decode(b'\x01\x64')
        b'\x80&'
        >>> data = numpy.array([1, 666], dtype='uint16')
        >>> _ = bitorder_decode(data)
        >>> data
        array([  128, 16473], dtype=uint16)

    s    @ `P0pH(hX8xD$dT4tL,l\<|B"bR2r
J*jZ:zF&fV6vN.n^>~A!aQ1q	I)iY9yE%eU5uM-m]=}C#cS3sK+k[;{G'gW7wO/o_?r   r^   rf   rG   r   z<bitorder_decode of slices requires the 'imagecodecs' packageN)appendr"   re   rf   r!   r   rd   	translaterj   take
ValueErrorrc   )r   r   r{   rj   excrs   s         r(   r   r     s    > 	 L!	
 	
 	
  	))A,ekJJJKKK$	*++ ,~~il+++0yy!!
9Q<400000 0 0 0L!#&&C/0 Ks   
2B= =
CCCr_   DTypeLike | Nonebitspersamplerunlenc                 ~|dk    rt          j        | d          }t          j        |          }|dk    rF|dz  rA|                    d|d|dz  z
  z   f          }|ddd|f                             d          }|                    |          S |dv rt          j        | |          S d| d	}t          |          )
a  Decompress bytes to array of integers.

    This implementation only handles itemsizes 1, 8, 16, 32, and 64 bits.
    Install the Imagecodecs package for decoding other integer sizes.

    Parameters:
        data:
            Data to decompress.
        dtype:
            Numpy boolean or integer type.
        bitspersample:
            Number of bits per integer.
        runlen:
            Number of consecutive integers after which to start at next byte.
        out:
            Output buffer (currently unused).

    Returns:
        Array of unpacked integers.

    Examples:
        >>> packints_decode(b'a', 'B', 1)
        array([0, 1, 1, 0, 0, 0, 0, 1], dtype=uint8)

    rG   z|Br      rO   N)r          @   zpackints_decode of z0-bit integers requires the 'imagecodecs' package)r"   re   
unpackbitsreshapeastyperc   )r   r_   r   r   r   
data_arrayrs   s          r(   r   r     s    D 	%dD11
%j11
A::&1*:#++R1vz>1J,KLLJ#AAAwwJ/77;;J  '''''e,,,	-m 	- 	- 	-  c
"
""r)   )rP   r   r   c              $    d}t          |          )zTightly pack integers.

    Parameters:
        data: Array of integers to pack.
        bitspersample: Number of bits per integer.
        axis: Axis along which to pack.
        out: Output buffer.

    Returns:
        Packed byte string.

    z2packints_encode requires the 'imagecodecs' packagerc   )r   r   rP   r   rs   s        r(   r   r   %  s    ( ?C
c
"
""r)   rk   Literal['>', '<']c               $    d}t          |          )zReturn float32 array from float24.

    Parameters:
        data: Bytes containing float24 values.
        byteorder: Byte order, either '>' (big-endian) or '<' (little-endian).

    Returns:
        Array of float32 values.

    z1float24_decode requires the 'imagecodecs' packager   )r   rk   rs   s      r(   r   r   =  s     >C
c
"
""r)   rU   )r   r   r   r   r   r   r   r   )r   r   r   r   r   r   )rE   r   r   r   r   r   )rO   rG   )
rP   rQ   rR   rQ   r   rS   r   r   r   r   )
rP   rQ   rR   rQ   r   rX   r   r   r   rX   )
rP   rQ   rR   rQ   r   r[   r   r   r   r   )r   rd   r   r   r{   r|   r   rd   )r   r   r   r   r{   r|   r   r   )r   rX   r   r   r{   r|   r   rX   )r   r[   r   r   r{   r|   r   r[   )r   )r_   r   r   rQ   r   rQ   r   r   r   r   r   rX   )
r   r   r   rQ   rP   rQ   r   r   r   rS   )rk   r   r   r   r   rX   ) __doc__
__future__r   __all__typingr   r   r"   r   r   numpy.typingr   r   r   r%   r	   r   ImportErrorr7   r   r   rC   r=   r   r   r
   r   r   r   r   r   r   rV   r)   r(   <module>r      s  @  # " " " " "    + * * * * * * *  ;########::::::::::6KKK
 !#
 # # # # # #( 37 	% 	% 	% 	% 	% 	% 	%    
 !
       37        .7KKK
 !B
 B B B B B B( 37 	% 	% 	% 	% 	% 	% 	%     !
       37        !06      
 !0
 0 0 0 0 0 0( 37 	% 	% 	% 	% 	% 	% 	%    
 !
       37        . 6: ' ' ' ' ' 'T 
 	      
 
78HL     
 	, , , , , , ,^ 
   

 
   
 	- - - - - - -` 

      
 

      
 

      
 : : : : : :D 0# 0# 0# 0# 0# 0# 0#p # # # # # #0# # # # # #s5   A AAA4 4BBB' 'B?>B?