✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

a

�iF�@s
dd
lm
Z
mZ
ddlmZ
ddlZddlZddlZddl	Z	ddl
Tddl
mZmZ
dd�Z
Gdd	�d	�ZGd
d�d�Zdd
�ZeGdd�d��
ZeGdd�de
��
Zdd�ZGdd�d�ZGdd�de
�Zdd�ZGdd�d�ZGdd�de�ZGdd�de�ZGd d!�d!�Zd"d#�ZdS)$�)�Sequence�Iterable)
�total_orderingN)
�
*)�_get_object_traceback�_get_tracescCs�d
D]|}t|�
dkr@|dkr@|
r0d||f
Sd||f
St|�
dksT|dkrx|
rhd||f
Sd	||f
S|d
}qdS)N)�
BZKiBZMiBZGiB�TiB�drz%+.1f %sz%.1f %si(r	z%+.0f %sz%.0f %si)
�abs)�size�signZunit�r�#/usr/lib64/python3.9/tracemalloc.py�_format_size
s





rc@sDeZ
dZd
ZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dS)�	StatisticzS
    Statistic difference on memory allocations between two Snapshot instance.
    ��	tracebackr�countcCs|
|_||_
||_dS�
Nr)�selfrrrrrr�__init__%s


zStatistic.__init__c

Cst|j
|j|jf�
Sr)�hashrrr�
rrrr�__hash__*s
zStatistic.__hash__cCs2t|
t
�stS|j|
jko0|j|
jko0|j|
jkSr)�
isinstancer�NotImplementedrrr�r�otherrrr�__eq__-s





�
�zStatistic.__eq__c
CsBd
|jt
|jd�|jf}
|jr>|j|j}|
dt
|d�7}
|
S)Nz%s: size=%s, count=%iF�, average=%s)rrrr�r�textZaveragerrr�__str__4s




��


zStatistic.__str__c

Csd
|j|j
|jfS)Nz)<Statistic traceback=%r size=%i count=%i>rrrrr�__repr__>s

�zStatistic.__repr__c

Cs|j|j
|jfSr)rrrrrrr�	_sort_keyBs
zStatistic._sort_keyN��__name__�
__module__�__qualname__�__doc__�	__slots__rrrr#r$r%rrrrrs

rc@sDeZ
dZd
ZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dS)�
StatisticDiffzd
    Statistic difference on memory allocations between an old and a new
    Snapshot instance.
    �rr�	size_diffr�
count_diffcCs"|
|_||_
||_||_||_dSrr-)rrrr.rr/rrrrMs





zStatisticDiff.__init__c

Cst|j
|j|j|j|jf�
Sr)rrrr.rr/rrrrrTs

�zStatisticDiff.__hash__cCsJt|
t
�stS|j|
jkoH|j|
jkoH|j|
jkoH|j|
jkoH|j|
jkSr)rr,rrrr.rr/rrrrrXs





�
�
�
�zStatisticDiff.__eq__c
CsPd
|jt
|jd�t
|jd�|j|jf}
|jrL|j|j}|
dt
|d�7}
|
S)Nz %s: size=%s (%s), count=%i (%+i)FTr )rrrr.rr/r!rrrr#as







��


zStatisticDiff.__str__c

Csd
|j|j
|j|j|jfS)Nz9<StatisticDiff traceback=%r size=%i (%+i) count=%i (%+i)>r-rrrrr$ms



��zStatisticDiff.__repr__c

Cs t|j
�
|jt|j�
|j|jfSr)rr.rr/rrrrrrr%rs


�zStatisticDiff._sort_keyNr&rrrrr,Fs
	r,cCs�g}|
��D]d\}}|�
|d�}|du
rNt||j|j|j|j|j|j�}nt||j|j|j|j�}|�|�

q|��D]*\}}t|d
|jd
|j�}|�|�

qz|S�Nr
)�items�popr,rr�append)�	old_group�	new_group�
statisticsr�statZpreviousrrr�_compare_grouped_statsxs"






�

�


r8c@s\eZ
dZd
ZdZdd�Zedd��
Zedd��
Zd	d
�Z	dd�Z
d
d�Zdd�Zdd�Z
dS)�Framez
    Frame of a traceback.
    �
�_framecCs
|
|_dSrr:�r�framerrrr�szFrame.__init__c

Cs
|jd
Sr0r:rrrr�filename�szFrame.filenamec

Cs
|jd
S�N�
r:rrrr�lineno�szFrame.linenocCst|
t
�stS|j|
jkSr�rr9rr;rrrrr�s



zFrame.__eq__cCst|
t
�stS|j|
jkSrrBrrrr�__lt__�s



zFrame.__lt__c

Cs
t|j
�
Sr)rr;rrrrr�s
zFrame.__hash__c

Csd
|j|j
fS)Nz%s:%s�r>rArrrrr#�s
z
Frame.__str__c

Csd
|j|j
fS)Nz<Frame filename=%r lineno=%r>rDrrrrr$�s
zFrame.__repr__N)r'r(r)r*r+r�propertyr>rArrCrr#r$rrrrr9�s



r9c@steZ
dZd
ZdZddd�
Zedd��
Zdd	�Zd
d�Z	dd
�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zddd�
ZdS)�	Tracebackz`
    Sequence of Frame instances sorted from the oldest frame
    to the most recent frame.
    )�_frames�
_total_nframeNcCs"t�
|�

tt|
�
�
|_||_dSr)rr�tuple�reversedrGrH)r�frames�total_nframerrrr�s


zTraceback.__init__c


Cs|jSr)
rHrrrrrL�szTraceback.total_nframec

Cs
t|j
�
Sr)�lenrGrrrr�__len__�s
zTraceback.__len__cCs4t|
t
�r"td
d�|j|
D�
�
St|j|
�
SdS)Nc
ss|]}
t|
�
V
qdSr)
r9��.0�tracerrr�	<genexpr>��z(Traceback.__getitem__.<locals>.<genexpr>)r�slicerIrGr9�r�indexrrr�__getitem__�s


zTraceback.__getitem__cCs|
j|j
vSr)r;rGr<rrr�__contains__�s
zTraceback.__contains__c

Cs
t|j
�
Sr)rrGrrrrr�s
zTraceback.__hash__cCst|
t
�stS|j|
jkSr�rrFrrGrrrrr�s



zTraceback.__eq__cCst|
t
�stS|j|
jkSrrYrrrrrC�s



zTraceback.__lt__c

Cst|d
�
Sr0)
�strrrrrr#�s
zTraceback.__str__c
Cs8d
t|�
��}
|j
dur"|
d7}
n|
d|j�d�7}
|
S)Nz<Traceback �
>z total_nframe=)rIrHrL)r�
srrrr$�s






zTraceback.__repr__FcCs�g}|
du
r2|
d
kr$||
d�}q6|d|
�}n|}|rBt|�
}|D]@}|�
d|j|jf�

t�|j|j���}|rF|�
d|�

qF|S)Nr
z  File "%s", line %sz    %s)rJr3r>rA�	linecache�getline�strip)r�limitZmost_recent_first�linesZframe_slicer=�linerrr�format�s 








�


zTraceback.format)
N)NF)r'r(r)r*r+rrErLrNrWrXrrrCr#r$rcrrrrrF�s
	

rFc
Cs t|�
}
|
d
u
rt
|
�
Sd
Sd
S)z�
    Get the traceback where the Python object *obj* was allocated.
    Return a Traceback instance.

    Return None if the tracemalloc module is not tracing memory allocations or
    did not trace the allocation of the object.
    N)rrF)�objrKrrr�get_object_traceback

s

rec@s`eZ
dZd
ZdZdd�Zedd��
Zedd��
Zed	d
��
Z	dd�Z
d
d�Zdd�Zdd�Z
dS)�Tracez"
    Trace of a memory block.
    �
�_tracecCs
|
|_dSrrg�rrQrrrr
szTrace.__init__c

Cs
|jd
Sr0rgrrrr�domain
szTrace.domainc

Cs
|jd
Sr?rgrrrrr
sz
Trace.sizec

Cst|j
d
d��S)N�)rFrhrrrrr#
szTrace.tracebackcCst|
t
�stS|j|
jkSr)rrfrrhrrrrr'
s



zTrace.__eq__c

Cs
t|j
�
Sr)rrhrrrrr,
s
zTrace.__hash__c

Csd
|jt
|jd�fS)Nz%s: %sF)rrrrrrrr#/
s
z
Trace.__str__c

Csd
|jt
|jd�|jfS)Nz'<Trace domain=%s size=%s, traceback=%r>F)rjrrrrrrrr$2
s

�zTrace.__repr__N)r'r(r)r*r+rrErjrrrrr#r$rrrrrf
s






rfc@s<eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
S)�_TracescCst�
|�

|
|_dSr)rr�_traces)r�tracesrrrr8
s

z_Traces.__init__c

Cs
t|j
�
Sr)rMrmrrrrrN=
s
z_Traces.__len__cCs4t|
t
�r"td
d�|j|
D�
�
St|j|
�
SdS)Nc
ss|]}
t|
�
V
qdSr)
rfrOrrrrRB
rSz&_Traces.__getitem__.<locals>.<genexpr>)rrTrIrmrfrUrrrrW@
s


z_Traces.__getitem__cCs|
j|j
vSr)rhrmrirrrrXF
s
z_Traces.__contains__cCst|
t
�stS|j|
jkSr)rrlrrmrrrrrI
s



z_Traces.__eq__c

Csd
t|�
S)Nz<Traces len=%s>)
rMrrrrr$N
s
z_Traces.__repr__N)	r'r(r)rrNrWrXrr$rrrrrl7
s
rlc

Cs&tj
�|�
}|�d
�
r"|dd�}|S)Nz.pyc���)�os�path�normcase�endswith)
r>rrr�_normalize_filenameR
s




rtc@seZ
dZd
d�Zdd�ZdS)�
BaseFiltercCs
|
|_dSr)
�	inclusive)rrvrrrrZ
s
zBaseFilter.__init__c
Cst�
dSr)
�NotImplementedErrorrirrr�_match]
s
zBaseFilter._matchN)r'r(r)rrxrrrrruY
s
rucsJeZ
dZd�f
dd�	Zedd��
Zdd�Zd	d
�Zdd�Zd
d�Z	�Z
S)�FilterNFcs2t��
|
�

|
|_t|�
|_||_||_||_dSr)�superrrvrt�_filename_patternrA�
all_framesrj)rrv�filename_patternrAr|rj�
�	__class__rrrb
s





zFilter.__init__c


Cs|jSr)
r{rrrrr}k
szFilter.filename_patterncCs6t|
�
}
t
�
|
|j�sd
S|jdur(dS||jkSdS)NFT)rt�fnmatchr{rA�rr>rArrr�_match_frame_implo
s





zFilter._match_frame_implcCs|�|
|�|j
ASr)r�rvr�rrr�_match_framex
s
zFilter._match_framecsH�jr,t
�f
d
d�|
D�
�
r"�jS�jSn|
d\}}��||�SdS)Nc
3s|]\}
}��|
|�V
qdSr)
r�)rPr>rArrrrR}
s
�z*Filter._match_traceback.<locals>.<genexpr>r
)r|�anyrvr�)rrr>rArrr�_match_traceback{
s


�

zFilter._match_tracebackcCsF|
\}}}}|�|�
}|j
du
rB|jr4|o2||j
kS|p@||j
kS|Sr)r�rjrv)rrQrjrrrL�resrrrrx�
s







z
Filter._match)NFN)r'r(r)rrEr}r�r�r�rx�
__classcell__rrr~rrya
s�	

	rycs0eZ
dZ�f
d
d�Zedd��
Zdd�Z�ZS)�DomainFiltercst��
|
�

||_dSr)rzr�_domain)rrvrjr~rrr�
s

zDomainFilter.__init__c


Cs|jSr)
r�rrrrrj�
szDomainFilter.domaincCs|
\}}}}||jk|j
ASr)rjrv)rrQrjrrrLrrrrx�
s

zDomainFilter._match)r'r(r)rrErjrxr�rrr~rr��
s


r�c@sXeZ
dZd
Zdd�Zdd�Zedd��
Zdd	�Zd
d�Z	dd
�Z
ddd�
Zddd�
ZdS)�SnapshotzB
    Snapshot of traces of memory blocks allocated by Python.
    cCst|
�
|_
||_dSr)rlrn�traceback_limit)rrnr�rrrr�
s

zSnapshot.__init__cCs>t|
d
�� }t
�||t
j�
Wd�
n1s00


Y
dS)z1
        Write the snapshot into a file.
        �wbN)�open�pickle�dump�HIGHEST_PROTOCOL)rr>�fprrrr��
s
z
Snapshot.dumpc
Cs8t|d
��}
t
�|
�
Wd�
S1s*0


Y
dS)z.
        Load a snapshot from a file.
        �rbN)r�r��load)r>r�rrrr��
s
z
Snapshot.loadcs@|
rt�f
d
d�|
D�
�
sdS|r<t�f
dd�|D�
�
r<dSdS)Nc
3s|]}
|
���
V
qdSr�
rx�rP�trace_filter�
rQrrrR�
s
�z)Snapshot._filter_trace.<locals>.<genexpr>Fc
3s|]}
|
���
V
qdSrr�r�r�rrrR�
s
�T)
r�)r�include_filters�exclude_filtersrQrr�r�
_filter_trace�
s


�


�
zSnapshot._filter_tracecs�t|
t
�std
t|
�
j�
�
|
rjg�
g�|
D] }|jrB�
�|�

q,��|�

q,��
�fdd��jjD�
}n�jj�	�}t
|�j�S)z�
        Create a new Snapshot instance with a filtered traces sequence, filters
        is a list of Filter or DomainFilter instances.  If filters is an empty
        list, return a new Snapshot instance with a copy of the traces.
        z)filters must be a list of filters, not %sc
sg|]}
���
�|
�r|
�qSr)
r�rO�r�r�rrr�
<listcomp>�
s



��z*Snapshot.filter_traces.<locals>.<listcomp>)rr�	TypeError�typer'rvr3rnrm�copyr�r�)r�filtersr�Z
new_tracesrr�r�
filter_traces�
s


�






zSnapshot.filter_tracesc
Cs�
|
d
v
rtd|
f
�
�
|r.|
dv
r.td|
�
�
i}i}|�
s|j
jD]�}|\}}}}	z||}
WnXty�


|
dkr||}n(|
dkr�|dd�}n|dddff
}t|�
}
|
||<Yn0z(||
}|j|7_|jd7_WqDt�
y


t|
|d�||
<YqD0qDn�|j
jD]�}|\}}}}	|D]�}
z||
}
WnDt�
y|


|
dk�
rZ|
f
}n|
ddff
}t|�
}
|
||
<Yn0z(||
}|j|7_|jd7_Wn$t�
y�


t|
|d�||
<Yn0�
q(�
q|S)	N)rr>rAzunknown key_type: %r)rAr>z/cumulative mode cannot by used with key type %rrrAr@r
)�
ValueErrorrnrm�KeyErrorrFrrr)r�key_type�
cumulativeZstatsZ
tracebacksrQrjrZtrace_tracebackrLrrKr7r=rrr�	_group_by�
sZ




�



































zSnapshot._group_byFcCs,|�|
|�}t
|���
}|jd
tjd�
|S)zd
        Group statistics by key_type. Return a sorted list of Statistic
        instances.
        T��reverse�key)r��list�values�sortrr%)rr�r�Zgroupedr6rrrr6s


zSnapshot.statisticscCs6|�||�}|
�||�}t
||�}|jd
tjd�
|S)z�
        Compute the differences with an old snapshot old_snapshot. Get
        statistics as a sorted list of StatisticDiff instances, grouped by
        group_by.
        Tr�)r�r8r�r,r%)rZold_snapshotr�r�r5r4r6rrr�
compare_tos





zSnapshot.compare_toN)
F)
F)
r'r(r)r*rr��staticmethodr�r�r�r�r6r�rrrrr��
s


3

r�cCs$t�st
d
�
�
t�}t�}
t||
�S)zI
    Take a snapshot of traces of memory blocks allocated by Python.
    zLthe tracemalloc module must be tracing memory allocations to take a snapshot)�
is_tracing�RuntimeErrorrZget_traceback_limitr�)rnr�rrr�
take_snapshot's



r�)�collections.abcrr�	functoolsrr�r]Zos.pathrpr�Z_tracemallocrrrrr,r8r9rFrerfrlrtruryr�r�r�rrrr�<module>
s2





(2
&
M'0