| Server IP : 162.144.4.212 / Your IP : 216.73.216.108 Web Server : Apache System : Linux gator2125.hostgator.com 5.14.0-162.23.1.9991722448259.nf.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Jul 31 18:11:45 UTC 2024 x86_64 User : cozeellc ( 2980) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /lib64/python3.9/site-packages/mercurial/utils/__pycache__/ |
Upload File : |
a
�+�b�d � @ s� d dl mZmZ d dlZd dlZd dlZddlmZ ddlm Z m
Z
mZ ddlm Z ej Z e
j
Z
dZd Ze�d
d �ZG d d
� d
e�ZG dd� de�Ze� ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG d d � d e�Z e� e � � G d d � d e�Z e� e � � G d d!� d!e�Z e� e � � G d"d#� d#e�Z e� e � � G d$d%� d%e�Z!e� e!� � d&d'� Z"e"� �#� Z$dS )(� )�absolute_import�print_functionN� )�getattr)�error�i18n�pycompat� )�
stringutils servers clientZcompenginewireprotosupport)�nameZserverpriorityZclientpriorityc @ s& e Zd Zdd� Zddd�Zdd� ZdS ) �
propertycachec C s || _ |j| _d S �N)�func�__name__r )�selfr � r �A/usr/lib64/python3.9/site-packages/mercurial/utils/compression.py�__init__& s zpropertycache.__init__Nc C s | � |�}| �||� |S r
)r �
cachevalue)r �obj�type�resultr r r �__get__* s
zpropertycache.__get__c C s ||j | j< d S r
)�__dict__r )r r �valuer r r r / s zpropertycache.cachevalue)N)r �
__module__� __qualname__r r r r r r r r % s
r c @ sz e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Ze d d
� �Z
e dd� �Z dd� Z dd� Z
d dd�Zdd� Zdd� ZdS ) �compressormanageraG Holds registrations of various compression engines.
This class essentially abstracts the differences between compression
engines to allow new compression formats to be added easily, possibly from
extensions.
Compressors are registered against the global instance by calling its
``register()`` method.
c C s" i | _ i | _i | _i | _i | _d S r
)�_engines� _bundlenames� _bundletypes�_revlogheaders�
_wiretypes�r r r r r ? s
zcompressormanager.__init__c C s
| j | S r
�r �r �keyr r r � __getitem__J s z compressormanager.__getitem__c C s
|| j v S r
r$ r% r r r � __contains__M s z compressormanager.__contains__c C s t | j�� �S r
)�iterr �keysr# r r r �__iter__P s zcompressormanager.__iter__c C s> t |t�sttd���|�� }|| jv r:t�td�| ��|�� }|r�|\}}|| j v rjt�td�| ��|| j
v r�t�td�|| j
| f ��|r�|| j |< || j
|< |� � }|r�|j}|| j v r�t�td�|| j | f ��|| j |< |�
� }|�r || jv �r t�td�|| j| f ��|�r0|| j|< || j|< dS )zxRegister a compression engine with the manager.
The argument must be a ``compressionengine`` instance.
s$ argument must be a compressionengines( compression engine %s already registereds! bundle name %s already registereds' bundle type %s already registered by %ss5 wire protocol compression %s already registered by %ss) revlog header %s already registered by %sN)�
isinstance�compressionengine�
ValueError�_r r r �Abort�
bundletyper r �wireprotosupportr" � revlogheaderr! ) r �enginer Z
bundleinfo�
bundlenamer1 Z wiresupport�wiretyper3 r r r �registerS sZ
�
�
��
� ��
��
zcompressormanager.registerc C s t | j�� �S r
)�setr r* r# r r r �supportedbundlenames� s z&compressormanager.supportedbundlenamesc C s t | j�� �S r
)r8 r r* r# r r r �supportedbundletypes� s z&compressormanager.supportedbundletypesc C s2 | j | j| }|�� s.t�td�|�� ��|S )z�Obtain a compression engine registered to a bundle name.
Will raise KeyError if the bundle type isn't registered.
Will abort if the engine is known but not available.
�) compression engine %s could not be loaded)r r � availabler r0 r/ r )r r5 r4 r r r �
forbundlename� s �z compressormanager.forbundlenamec C s2 | j | j| }|�� s.t�td�|�� ��|S )z�Obtain a compression engine registered to a bundle type.
Will raise KeyError if the bundle type isn't registered.
Will abort if the engine is known but not available.
r; )r r r< r r0 r/ r )r r1 r4 r r r �
forbundletype� s �z compressormanager.forbundletypeTc sV |t kr dnd� �fdd��j�� D �}|r:dd� |D �}� fdd�}tt||d��S ) z�Obtain compression engines that support the wire protocol.
Returns a list of engines in prioritized order, most desired first.
If ``onlyavailable`` is set, filter out engines that can't be
loaded.
s serverprioritys clientpriorityc s g | ]}� j | �qS r r$ ��.0�er# r r �
<listcomp>� � z:compressormanager.supportedwireengines.<locals>.<listcomp>c S s g | ]}|� � r|�qS r )r< r? r r r rB � rC c s | � � }dt|� � |jfS )N���)r2 r r )rA �w)�attrr r �getkey� s z6compressormanager.supportedwireengines.<locals>.getkey)r& )�
SERVERROLEr" �values�list�sorted)r ZroleZ
onlyavailableZenginesrG r )rF r r �supportedwireengines� s
z&compressormanager.supportedwireenginesc C s2 | j | j| }|�� s.t�td�|�� ��|S )Nr; )r r" r< r r0 r/ r )r r6 r4 r r r � forwiretype� s �z compressormanager.forwiretypec C s | j | j| S )z�Obtain a compression engine registered to a revlog header.
Will raise KeyError if the revlog header value isn't registered.
)r r! )r �headerr r r �forrevlogheader� s z!compressormanager.forrevlogheaderN)T)r r r �__doc__r r' r( r+ r7 �propertyr9 r: r= r> rL rM rO r r r r r 4 s
=
r c @ sT e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zdd
d�Z dd� Z
ddd�Z d S )r- zuBase class for compression engines.
Compression engines must implement the interface defined by this class.
c C s
t � �dS )z�Returns the name of the compression engine.
This is the key the engine is registered under.
This method must be implemented.
N��NotImplementedErrorr# r r r r � s zcompressionengine.namec C s dS )a Whether the compression engine is available.
The intent of this method is to allow optional compression engines
that may not be available in all installations (such as engines relying
on C extensions that may not be present).
Tr r# r r r r< � s zcompressionengine.availablec C s dS )a� Describes bundle identifiers for this engine.
If this compression engine isn't supported for bundles, returns None.
If this engine can be used for bundles, returns a 2-tuple of strings of
the user-facing "bundle spec" compression name and an internal
identifier used to denote the compression format within bundles. To
exclude the name from external usage, set the first element to ``None``.
If bundle compression is supported, the class must also implement
``compressstream`` and `decompressorreader``.
The docstring of this method is used in the help system to tell users
about this engine.
Nr r# r r r r1 � s z compressionengine.bundletypec C s dS )a� Declare support for this compression format on the wire protocol.
If this compression engine isn't supported for compressing wire
protocol payloads, returns None.
Otherwise, returns ``compenginewireprotosupport`` with the following
fields:
* String format identifier
* Integer priority for the server
* Integer priority for the client
The integer priorities are used to order the advertisement of format
support by server and client. The highest integer is advertised
first. Integers with non-positive values aren't advertised.
The priority values are somewhat arbitrary and only used for default
ordering. The relative order can be changed via config options.
If wire protocol compression is supported, the class must also implement
``compressstream`` and ``decompressorreader``.
Nr r# r r r r2
s z"compressionengine.wireprotosupportc C s dS )aP Header added to revlog chunks that identifies this engine.
If this engine can be used to compress revlogs, this method should
return the bytes used to identify chunks compressed with this engine.
Else, the method should return ``None`` to indicate it does not
participate in revlog compression.
Nr r# r r r r3 # s z compressionengine.revlogheaderNc C s
t � �dS )a� Compress an iterator of chunks.
The method receives an iterator (ideally a generator) of chunks of
bytes to be compressed. It returns an iterator (ideally a generator)
of bytes of chunks representing the compressed output.
Optionally accepts an argument defining how to perform compression.
Each engine treats this argument differently.
NrR �r �it�optsr r r �compressstream- s
z compressionengine.compressstreamc C s
t � �dS )z�Perform decompression on a file object.
Argument is an object with a ``read(size)`` method that returns
compressed data. Return value is an object with a ``read(size)`` that
returns uncompressed data.
NrR �r �fhr r r �decompressorreader9 s z$compressionengine.decompressorreaderc C s
t � �dS )aL Obtain an object that can be used to compress revlog entries.
The object has a ``compress(data)`` method that compresses binary
data. This method returns compressed binary data or ``None`` if
the data could not be compressed (too small, not compressible, etc).
The returned data should have a header uniquely identifying this
compression format so decompression can be routed to this engine.
This header should be identified by the ``revlogheader()`` return
value.
The object has a ``decompress(data)`` method that decompresses
data. The method will only be called if ``data`` begins with
``revlogheader()``. The method should return the raw, uncompressed
data or raise a ``StorageError``.
The object is reusable but is not thread safe.
NrR �r rV r r r �revlogcompressorB s z"compressionengine.revlogcompressor)N)N) r r r rP r r< r1 r2 r3 rW rZ r\ r r r r r- � s
r- c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_CompressedStreamReaderc C s2 t |d�r|j| _n|j| _g | _d| _d| _d S )N�unbufferedreadr F)� safehasattrr^ �_reader�read�_pending�_pos�_eofrX r r r r X s
z _CompressedStreamReader.__init__c C s
t � �d S r
rR )r �chunkr r r � _decompressa s z#_CompressedStreamReader._decompressc C s� g }| j r�t| j d �|| j kr^| j d }|�|| j| j| � � | j|7 _d�|�S | j �d�}| jr�|�|| jd � � |t|�| j 8 }n|�|� |t|�8 }d| _q| jr�d�|�S | �d�}| �|� |s| j s| jsd�|�S qd S )Nr rC i ) rb �lenrc �append�join�poprd r` rf )r �l�buf�newbufre r r r ra d s(
z _CompressedStreamReader.readN)r r r r rf ra r r r r r] W s r] c s$ e Zd Z� fdd�Zdd� Z� ZS )�_GzipCompressedStreamReaderc s t t| ��|� t�� | _d S r
)�superrn r �zlib�
decompressobj�
_decompobjrX �� __class__r r r � s z$_GzipCompressedStreamReader.__init__c C sf | j �|�}|r | j�|� | j �� }z&|�d� |�� |jdkrJd| _W n tj y` Y n0 d S )N� xT)
rr �
decompressrb rh �copy�flush� unused_datard rp r )r re rm �dr r r rf � s
z'_GzipCompressedStreamReader._decompress�r r r r rf �
__classcell__r r rs r rn � s rn c s$ e Zd Z� fdd�Zdd� Z� ZS )�_BZ2CompressedStreamReaderc s t t| ��|� t�� | _d S r
)ro r} r �bz2�BZ2Decompressorrr rX rs r r r � s z#_BZ2CompressedStreamReader.__init__c C s` | j �|�}|r | j�|� z&| j �d�}|r@| j�|� q q@q W n tyZ d| _Y n0 d S �NrC T)rr rv rb rh �EOFErrorrd �r re rm r r r rf � s z&_BZ2CompressedStreamReader._decompressr{ r r rs r r} � s r} c s e Zd Z� fdd�Z� ZS )�#_TruncatedBZ2CompressedStreamReaderc s0 t t| ��|� | j�d�}|r,| j�|� d S )N� BZ)ro r� r rr rv rb rh )r rY rm rs r r r � s z,_TruncatedBZ2CompressedStreamReader.__init__)r r r r r| r r rs r r� � s r� c s$ e Zd Z� fdd�Zdd� Z� ZS )�_ZstdCompressedStreamReaderc s( t t| ��|� || _|�� �� | _d S r
)ro r� r �_zstd�ZstdDecompressorrq rr )r rY �zstdrs r r r � s z$_ZstdCompressedStreamReader.__init__c C sd | j �|�}|r | j�|� z&| j �d�}|r@| j�|� q q@q W n | jjy^ d| _Y n0 d S r� )rr rv rb rh r� Z ZstdErrorrd r� r r r rf � s z'_ZstdCompressedStreamReader._decompressr{ r r rs r r� � s r� c @ sX e Zd Zdd� Zdd� Zdd� Zdd� Zdd
d �Zd d
� ZG dd� de �Z
ddd�Z d S )� _zlibenginec C s dS )N� zlibr r# r r r r � s z_zlibengine.namec C s dS )z�zlib compression using the DEFLATE algorithm.
All Mercurial clients should support this format. The compression
algorithm strikes a reasonable balance between compression ratio
and size.
)s gzips GZr r# r r r r1 � s z_zlibengine.bundletypec C s t ddd�S )Nr� � ��compewireprotosupportr# r r r r2 � s z _zlibengine.wireprotosupportc C s dS )Nru r r# r r r r3 � s z_zlibengine.revlogheaderNc c sF |pi }t �|�dd��}|D ]}|�|�}|r |V q |�� V d S )N� levelrD )rp � compressobj�get�compressrx �r rU rV �zre �datar r r rW � s
z_zlibengine.compressstreamc C s t |�S r
)rn rX r r r rZ � s z _zlibengine.decompressorreaderc @ s& e Zd Zddd�Zdd� Zdd� ZdS ) z _zlibengine.zlibrevlogcompressorNc C s
|| _ d S r
)�_level)r �levelr r r r � s z)_zlibengine.zlibrevlogcompressor.__init__c C s� t |�}|dk rd S |dkrT| jd u r2t�|�}nt�|| j�}t |�|k rP|S d S | jd u rht�� }ntj| jd�}g }d}||k r�|d }|�|�|||� �� |}q~|�|�� � ttt |��|k r�d� |�S d S d S )N�, �@B �r� r i rC )
rg r� rp r� r� rh rx �sum�mapri )r r� �insize�
compressedr� �parts�pos�pos2r r r r� � s.
z)_zlibengine.zlibrevlogcompressor.compressc
C sP z t �|�W S t jyJ } z$t�td�t�|� ��W Y d }~n
d }~0 0 d S )N� revlog decompress error: %s)rp rv r � StorageErrorr/ r
� forcebytestr)r r� rA r r r rv s ��z+_zlibengine.zlibrevlogcompressor.decompress)N�r r r r r� rv r r r r �zlibrevlogcompressor� s
%r� c C s d }|d ur|� d�}| �|�S )Ns
zlib.level)r� r� �r rV r� r r r r\ s
z _zlibengine.revlogcompressor)N)N) r r r r r1 r2 r3 rW rZ �objectr� r\ r r r r r� � s
2r� c @ s6 e Zd Zdd� Zdd� Zdd� Zd dd �Zd
d � ZdS )
�
_bz2enginec C s dS )Ns bz2r r# r r r r $ s z_bz2engine.namec C s dS )a� An algorithm that produces smaller bundles than ``gzip``.
All Mercurial clients should support this format.
This engine will likely produce smaller bundles than ``gzip`` but
will be significantly slower, both during compression and
decompression.
If available, the ``zstd`` engine can yield similar or better
compression at much higher speeds.
)� bzip2r� r r# r r r r1 ' s z_bz2engine.bundletypec C s t ddd�S )Nr� r r� r# r r r r2 7 s z_bz2engine.wireprotosupportNc c sF |pi }t �|�dd��}|D ]}|�|�}|r |V q |�� V d S )Nr� � )r~ �
BZ2Compressorr� r� rx r� r r r rW : s
z_bz2engine.compressstreamc C s t |�S r
)r} rX r r r rZ D s z _bz2engine.decompressorreader)N)r r r r r1 r2 rW rZ r r r r r� # s
r� c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�_truncatedbz2enginec C s dS )Ns bz2truncatedr r# r r r r L s z_truncatedbz2engine.namec C s dS )N)Ns _truncatedBZr r# r r r r1 O s z _truncatedbz2engine.bundletypec C s t |�S r
)r� rX r r r rZ T s z&_truncatedbz2engine.decompressorreaderN)r r r r r1 rZ r r r r r� K s r� c @ sX e Zd Zdd� Zdd� Zdd� Zdd� Zdd
d �Zd d
� ZG dd� de �Z
ddd�Z d S )� _noopenginec C s dS )N� noner r# r r r r \ s z_noopengine.namec C s dS )zmNo compression is performed.
Use this compression engine to explicitly disable compression.
)r� s UNr r# r r r r1 _ s z_noopengine.bundletypec C s t ddd�S )Nr� r �
r� r# r r r r2 i s z _noopengine.wireprotosupportc C s dS )N� r r# r r r r3 n s z_noopengine.revlogheaderNc C s |S r
r rT r r r rW q s z_noopengine.compressstreamc C s |S r
r rX r r r rZ t s z _noopengine.decompressorreaderc @ s e Zd Zdd� ZdS )z _noopengine.nooprevlogcompressorc C s d S r
r )r r� r r r r� x s z)_noopengine.nooprevlogcompressor.compressN)r r r r� r r r r �nooprevlogcompressorw s r� c C s | � � S r
)r� r[ r r r r\ { s z _noopengine.revlogcompressor)N)N) r r r r r1 r2 r3 rW rZ r� r� r\ r r r r r� [ s
r� c @ sl e Zd Zdd� Zedd� �Zdd� Zdd� Zd d
� Zd d � Z ddd�Z
dd� Z G dd� de �Z
ddd�Zd
S )� _zstdenginec C s dS )N� zstdr r# r r r r � s z_zstdengine.namec C s2 zddl m} |j |W S ty, Y d S 0 d S )Nr )r� )� r� � __version__� ImportError)r r� r r r �_module� s z_zstdengine._modulec C s
t | j�S r
)�boolr� r# r r r r< � s z_zstdengine.availablec C s dS )a� A modern compression algorithm that is fast and highly flexible.
Only supported by Mercurial 4.1 and newer clients.
With the default settings, zstd compression is both faster and yields
better compression than ``gzip``. It also frequently yields better
compression than ``bzip2`` while operating at much higher speeds.
If this engine is available and backwards compatibility is not a
concern, it is likely the best available engine.
)r� s ZSr r# r r r r1 � s z_zstdengine.bundletypec C s t ddd�S )Nr� �2 r� r# r r r r2 � s z _zstdengine.wireprotosupportc C s dS )N� (r r# r r r r3 � s z_zstdengine.revlogheaderNc c sd |pi }|� dd�}|� dd�}| j}|j||d��� }|D ]}|�|�}|r<|V q<|�� V d S )Nr� � s threadsr )r� �threads)r� r� �ZstdCompressorr� r� rx ) r rU rV r� r� r� r� re r� r r r rW � s
z_zstdengine.compressstreamc C s t || j�S r
)r� r� rX r r r rZ � s z _zstdengine.decompressorreaderc @ s& e Zd Zd dd�Zdd� Zdd� ZdS )
z _zstdengine.zstdrevlogcompressorr� c C s, |j |d�| _|�� | _|j| _|j| _d S )Nr� )r� �_cctxr� �_dctxZ"COMPRESSION_RECOMMENDED_INPUT_SIZE� _compinsizeZ$DECOMPRESSION_RECOMMENDED_INPUT_SIZE�
_decompinsize)r r� r� r r r r � s
z)_zstdengine.zstdrevlogcompressor.__init__c C s� t |�}|dk rd S |dkr<| j�|�}t |�|k r8|S d S | j�� }g }d}||k r�|| j }|�|||� �}|r�|�|� |}qN|�|�� � ttt |��|k r�d� |�S d S d S )Nr� r� r rC )
rg r� r� r� r� rh rx r� r� ri ) r r� r� r� r� �chunksr� r� re r r r r� � s*
z)_zstdengine.zstdrevlogcompressor.compressc
C s� t |�}zV| j�� }g }d}||k rT|| j }|�|||� �}|rN|�|� |}q d�|�W S ty� } z$t� t
d�t � |� ��W Y d }~n
d }~0 0 d S )Nr rC r� )
rg r� rq r� rv rh ri � Exceptionr r� r/ r
r� ) r r� r� Zdobjr� r� r� re rA r r r rv � s$
��z+_zstdengine.zstdrevlogcompressor.decompressN)r� r� r r r r �zstdrevlogcompressor� s
r� c C s@ |pi }|� d�}|d u r$|� d�}|d u r0d}| j| j|d�S )Ns
zstd.levelr� r� r� )r� r� r� r� r r r r\ � s
z _zstdengine.revlogcompressor)N)N)r r r r r r� r< r1 r2 r3 rW rZ r� r� r\ r r r r r� � s
@r� c C s� i } G dd� dt �}tD ]t}t| }|�� s.q|�� }|r|d sDqd|d t�|j�f }|� }t�|�|_|jj|_|j|_ || |d < q| S )z@Obtains a list of available bundle compressions for use in help.c @ s e Zd ZdS )z*bundlecompressiontopics.<locals>.docobjectN)r r r r r r r � docobject s r� r s
``%s``
%s)
r� � compenginesr< r1 r ZgetdocZsysstrrP Z_origdocZ _origfunc)�itemsr� r r4 Zbt�docr r r r �bundlecompressiontopics s
r� )%Z
__future__r r r~ � collectionsrp r r r� r r r
r_ r/ rH Z
CLIENTROLE�
namedtupler� r� r r r� r- r] rn r} r� r� r� r7 r� r� r� r� r� rI Z
i18nfunctionsr r r r �<module> sJ � *w)\ %
$