�
;�Pc@s/dd
lZ
de
jjjf
d��YZd
S(i����Nt_GLUECLAMP_cBsv
eZ
dtZduZdvZdwZd/Zd0�Zd1�Zd2�Z	d3�Z
d4�Zd5�Zd6�Z
e
Zd7d8�
Zd9�Zd:d;�
Zd:d<d:d=�Zd>�Zd<d?�
Zd@�ZdA�ZdB�ZdxdxdC�ZdxdD�
ZdxdE�
Zdxd:dF�ZedG�
ZdyZddZ deZ!dfZ"dgZ#dhZ$diZ%djZ&dkZ'dlZ(dmZ)dnZ*doZ+dpZ,dqZ-drZ.dsZ/RS(zt_hiding_tag_treprefixtdefault_reprefixtgcobjstrelheaptrelheapgtrelheaput__doc__tAnythingtClasstClodotIdtIdsettModuletNothingtRcstRoottSizetTypetUnitytViatdoctfindextheaptheaputidsettisotloadtmonitortpbtsetrefttesttViewt
_load_stattctimetdumphtheapgtloadct
setrelheaptsetrelheapgtsetrelheaputtc_adaptttc_reprtuniontuniset_from_setcsatabletwarningstStatshpy().c


Cs|jS(
N(
R(
tself((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt_get_gcobjss
c


Cs|jS(
N(
R(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt_get_relheaps
c


Cs|jS(
N(
R(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt
_get_relheapgs
c


Cs|jS(
N(
R(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt
_get_relheapu"s
c
Cshd
dl}
xR|
j
j�D]A\}}t||j�rt|dd�|jkrd|SqW|jS(Ni����t_shares%s.(	t__main__t__dict__titemst
isinstancet	__class__tgetattrtNoneR5R(R0R6t
kt
v((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt
_get_reprefix%s




c


Cs
|jj
jS(
sM
Root: RootStateType

This attribute is a symbolic root containing attributes from which all
reachable objects in the heap can be reached. It is the only value (a
singleton) of its kind; see [1] for a description of its attributes.

References
	[0] heapy_Use.html#heapykinds.Use.Root
	[1] heapy_RootState.html#heapykinds.RootStateType(R!theapyct	RootState(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt	_get_Root1sc

Csd
|j|jd fS(Ns@Top level interface to Heapy.
Use eg: %sdoc for more info on %s.i����(
R(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt__repr__>s
tcCs"|}|jj
jjj||
�S(
s=        #OBSOLETE
$HP.dir(opts: str+])-> GuppyDir
$HP.dir(opts: str+]).<attribute> -> GuppyDoc

A replacement for the builtin function dir(), providing a listing of
public attributes for Heapy objects. It also has an attribute for each
item in the listing, for example:

>>> $HP.dir().heap

returns a GuppyDoc object providing documentation for the heap
method. The method also takes a string argument specifying further
options. Currently the following are provided:

        'l'	Generate a listing of the synopsis lines.
	'L'	Generate a listing of the entire doc strings.(t_roottguppytetctHelptdir(R0toptstobj((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pytDdirGs
c

Cs,|jj
jjj|d
ddd|j�
S(s�Overview documentation for top level Heapy object.
Provides a listing of the available attributes.
Accessing the attribute name on the doc objects gives further info, eg:

    >>> hp.doc.heap

gives doc for the heap method when hp is the top level Heapy object.

References may be embedded in the documentations. To access a
reference, opening up a web browser with the doc for it one can do eg:

    >>> hp.doc.heap[1]

The reference number 0 is special. If it is provided, it is the
reference to the html doc for the described object itself. So to see
in the web browser the doc for the heap method one can do:

    >>> hp.doc.heap[0]

References
    [0] heapy_Use.html#heapykinds.Use.doctheaders3Top level interface to Heapy. Available attributes:tfooters2Use eg: %sdoc.<attribute> for info on <attribute>.(RERFRGRHRIR(
R0((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt_get_doc]si
cCs3|jj
d
�

|jj|
�
}||j8}|S(s DEPRECATED sIMethod Use.heapg is depreciated, it doesn't work well. Use heapu instead.(R.twarnR!R%R(R0trmat
h((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR%{s
	




icCs�|jj
|
�
}d
}|rV|jrVt|jt|�
�rV||j8}d}n|r�|j}|r�|jr�t|jt|�
�r�||j8}d}nd|_|r�|jd|j|jj�
7_n|jd7_n|S(sheapu() -> Stat 

Finds the objects in the heap that remain after garbage collection but
are _not_ reachable from the root.  This can be used to find objects
in extension modules that remain in memory even though they are
gc-collectable and not reachable.

Returns an object containing a statistical summary of the objects
found - not the objects themselves. This is to avoid making the
objects reachable.

See also: setref[1]

References
    [0] heapy_Use.html#heapykinds.Use.heapu
    [1] heapy_Use.html#heapykinds.Use.setrefii
sData from unreachable objectss relative to: %ss.
(	R!RRR9ttypetstattfirstheaderR#ttimemade(R0RQtabsRTRRtrel((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR�s 

(


	

	
(


		



c
Cs-|jj
�}
|
|jO}
|
|j8}
|
S(
sheap() -> IdentitySet[1]

Traverse the heap from a root to find all reachable and visible
objects. The objects that belong to a heapy instance are normally not
included. Return an IdentitySet with the objects found, which is
presented as a table partitioned according to a default equivalence
relation (Clodo [3]).

See also: setref[2]

References
    [0] heapy_Use.html#heapykinds.Use.heap
    [1] heapy_UniSet.html#heapykinds.IdentitySet
    [2] heapy_Use.html#heapykinds.Use.setref
    [3] heapy_Use.html#heapykinds.Use.Clodo(R!RRR(R0RR((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR�s




c	s�
t�
t
�r-t�
�
��f
d
�}n�t�
d�r^t�
d�r^�
f
d�}n�t�
d�r 
|r�
j}n	�
j}g�|�}|s�t�
nd|}y=x6|r��j|�

||kr�Pn|�}q�Wt�
Wntk
r




�j|�

n
X�f
d�}n	td�t	|��
j�}|j
d�
s]
td	�
�n||jd
�
dj
�}yt||�}Wn$tk
r�



td�
|f�n
X||�
S(
s�load(alt:[fn: loadablefilenamestring+ or
          fn: loadableiterableofstrings+]
     [use_readline = boolean+]) -> Stat

Load heapy-related data from a serialized form. Currently it handles
data generated by Stat.dump.

Arguments
    fn: loadablefilenamestring+
        A string argument is treated as a file name.
    fn: loadableiterableofstrings+
        An open file or an iterator will be iterated over enough
        to read one package of data, and another call to load
        will read the next package.
    use_readline = boolean+
        If true, the method will use .readline() instead of
        iteration, which may be necessary in case the input
        comes from a pipe since otherwise the Python runtime
        would try to read ahead a big block before returning the
        first package of data.
Returns
    one package of statistical data.

References
    [0] heapy_Use.html#heapykinds.Use.loadc3sEd
}x8�j|�

�j
�}
|
s,Pn�j�}|
V
q	WdS(Ni(tseektreadlinettell(tpostline(
t
f(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt	get_trows�s








t__iter__tnextc
s�S(
N(((
tfn(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR_�s
s.end: %sc
s�S(
N(((
ttrows(sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR_
s
sBArgument should be a string, file or an iterable yielding strings.s.loader:s1Format error in %r: no initial .loader directive.t
:i
s'Format error in %r: no such loader: %r.(R9t
basestringtopenthasattrRZRat
StopIterationtappendt	TypeErrortitert
startswitht
ValueErrortindextstripR;tAttributeError(	R0Rbtuse_readlineR_tget_lineR]tendlinet
atloader((R^RbRcsB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR�sD	
	

	
	

	



	









	








ccs=t|
t
�rt|
�
}
nxtr8|j|
�
V
q!Wd
S(s< Generates all objects from an open file f or a file named fN(R9ReRftTrueR(R0R^((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pytloadall"
s

	
cCs1t|
d
d�}x|j
|dd�

GHqWdS(Nt
ri
Rq(RfR(R0RbR^((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR&)
s


cCs]t|
d
�}ddl
}x;|j�}|jj|�

|j�
t|j��
GHqWdS(Nt
wi����(RftgcRRTtdumptflushtlentget_objects(R0RbR^Rzt
x((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR$.
s







cCsk|
d
kr/|d
kr/|j
�
|j�
n8|
d
k	rK|j
|
�

n|d
k	rg|j|�

nd
S(s�
setref()

Set a reference point for heap usage measurement.  This applies to
both the heap[1] and heapu[2] methods. The heap() method will only
show the objects allocated after the time setref was called. The
heapu() method, since it deals with summary data and not actual
objects, will show the difference of sizes and counts compared to when
setref was called.

References
    [0] heapy_Use.html#heapykinds.Use.setref
    [1] heapy_Use.html#heapykinds.Use.heap
    [2] heapy_Use.html#heapykinds.Use.heapuN(R<R'R)(R0t	reachabletunreachable((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR7
s






cCs+|
dkr|j
j�}
n|
|_dS(
N(R<R!RR(R0t	reference((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR'O
s


cCsD|jj
d
�

|
dkr7d|_|jj�}
n|
|_dS(Ns:Method Use.setrelheapg is depreciated, use setref instead.(R.RPR<RR!R%(R0R�((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR(T
s
	


	

cCsb|
dkr0d|_
|jd
td|�}
n|rUt|
|j�rU|
j}
n|
|_
dS(NRWRT(R<RRRvR9R/RT(R0R�RT((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR)\
s

	



cCs|jj
jj|
�

d
S(s�test([debug: bool+ = False])

Run the Heapy test suite.

Argument
    debug
        If True, the tests will be run in debug mode so the stack frame
        can be examined with pdb.pm() after the first exception.N(t_parentR ttest_allt	test_main(R0tdebug((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyR d
s
s_parent.Classifiers:Classs_parent.Classifiers:Clodos_parent.Classifiers:Ids_parent.Classifiers:Idsets_parent.Classifiers:Modules_parent.Classifiers:Rcss_parent.Classifiers:Sizes_parent.Classifiers:Types_parent.Classifiers:Unitys_parent.Classifiers:Vias_parent.Classifiers:findexs_parent.Classifiers:sonokinds_parent.Classifiers:tc_adapts_parent.Classifiers:tc_reprs_parent.Monitor:monitors_parent.Part:_load_stats_parent.Part:Stats_parent.Prof:pbs_parent.UniSet:Anythings_parent.UniSet:idsets_parent.UniSet:isos_parent.UniSet:Nothings_parent.UniSet:unions&_parent.UniSet:uniset_from_setcastables_parent:Views_parent.View:_hiding_tag_s_root.time:ctimes_root:warningss�Anything: Kind

A symbolic set that represents all possible Python objects.

References
    [0] heapy_Use.html#heapykinds.Use.Anythingsr
Class:EquivalenceRelation
Class(tc:typeorclass+) -> Kind

Equivalence relation by class. It defines objects to be equivalent
when their builtin __class__ attributes are identical. When called it
returns the equivalenc class defined by the argument:

    tc: A type or class that the returned kind should represent.

References
    [0] heapy_Use.html#heapykinds.Use.Classs�Clodo:EquivalenceRelation
Clodo(alt:[tc: typeorclassexceptdict+ or dictof =
        typeorclassoremptytuple+]) -> Kind

Equivalence relation by class or dict owner. It distinguishes between
objects based on their class just like the Class relation, and in
addition distinguishes between dicts depending on what class they are
'owned' by, i.e. occur in __dict__ attribute of.

When called it returns the equivalence class defined by the argument,

EITHER:
    tc: A positional argument, a type or class but not a dict, to
        create the corresponding equivalence class.
OR:
    dictof: A named argument, to create an equivalence class
        consisting of all dicts that are owned by objects of the type
        or class specified in the argument; or dicts with no owner if
        an empty tuple is given. XXX express this simpler&better...


References
    [0] heapy_Use.html#heapykinds.Use.ClodosY
Id:EquivalenceRelation
Id(address: objectaddress+) -> Kind)

This equivalence relation defines objects to be equivalent only if
they are identical, i.e. have the same address. When called it returns
the equivalence class defined by the argument:

    address: The memory address of an object.

References
    [0] heapy_Use.html#heapykinds.Use.Ids�
Id:EquivalenceRelation
Idset(node: Anything+) -> IdentitySet

This equivalence relation defines objects to be equivalent only if
they are identical, i.e. have the same address. When called it returns
the equivalence class defined by the argument:

    node: Anything+
        Any object is a valid argument.

Note
    This is mainly for special purpose internal use. The Id
equivalence relation is more efficient when partitioning large
sets.s�Module:EquivalenceRelation
x.Module( draw:[name = modulename+ , at = moduleaddress+]) -> Kind

This equivalence relation defines objects to be equivalent if they are
the same module, or if none of them is a module.  Partitioning a set
of objects using this equivalence relation will therefore result in
one singleton set for each module and one set containing all other
objects.

Calling the Module equivalence relation creates a Kind containing the
module given in the keyword argument(s). Either the name, address or
both may be specified. If no argument is specified the equivalence
class is that of non-module objects.

References
    [0] heapy_Use.html#heapykinds.Use.Modules^Nothing: IdentitySet

The empty set.

References
    [0] heapy_Use.html#heapykinds.Use.NothingsRcs: EquivalenceRelation
Rcs ( 0..*: alt:[kind: Kind+ or sok: SetOfKind+]) -> KindOfRetClaSetFamily

(Referrer classification set.)

In this equivalence relation, objects are classified by classifying
their referrers, using the Clodo equivalence relation. These
classifications are collected in a set, representing the
classification of the object.

Calling Rcs creates an equivalence class from specified set of
referrer classifications. The arguments specify a set of Kind objects,
each of which representing an equivalence class of Clodo.

    kind: Kind+
        This adds a single Kind to the set of Kinds of referrers.
    sok: SetOfKind+
        This adds each Kind in the sok argument to the total set of
        Kinds of referrers.
References
    [0] heapy_Use.html#heapykinds.Use.Rcss?
Size: EquivalenceRelation
Size(size: notnegative+) -> KindOfSizeFamily[1])

In this equivalence relation, objects are classified by memory size,
so each equivalence class represents a particular size of object.

References
    [0] heapy_Use.html#heapykinds.Use.Size
    [1] heapy_UniSet.html#heapykinds.KindOfSizeFamilys�
Type: EquivalenceRelation
Type(type: type+) -> KindOfTypeFamily[1]

In this equivalence relation, objects are classified by type so each
equivalence class represents objects of a particular type.  Calling it
creates a Kind representing the type specified in the argument:

    type: type+
        A Python type object or a representation of it.

References
    [0] heapy_Use.html#heapykinds.Use.Type
    [1] heapy_UniSet.html#heapykinds.KindOfTypeFamilys?
Unity: EquivalenceRelation
Unity() -> Kind[1]

In this equivalence relation, all objects are considered equivalent.
There is only one equivalence class, that is, Anything[2].

References
    [0] heapy_Use.html#heapykinds.Use.Unity
    [1] heapy_UniSet.html#heapykinds.Kind
    [2] heapy_Use.html#heapykinds.Use.Anythings�Via: EquivalenceRelation
Via( 0..*:rel: relationname+) -> KindOfInViaFamily[1]

In this equivalence relation, objects are classified by how they are
referred from their referrers, so each equivalence class represents
objects that have a particular set of relations to their referrers.
Calling it creates a Kind representing the set of referrers specified
by the argument:

    rel: relationname+
        Each argument specifies one referrer relation. The arguments
        should be strings and can be of any of the following forms.

[expression]
    Indexing of a dict, list, tuple (etc).  The expression must be a
    Python expression that can be evaluated in a local
    environment. The environment will contain the builtins and a name
    'hp' that is bound to the current Use instance.

.attribute
    Getting an attribute from a builtin type or a slot of a slotted
    type. (I.E. not an attribute that is in a dict of an object.)

.f_locals["name"]
     A local variable of a frame.

.f_locals ["name"]
    A variable in a CELL of a frame. Note the space between f_locals and
    [. This is to distinguish it from ordinary locals, and still use a
    syntax that could be used to access those variables directly from
    Python.

.keys()[integer]
    A key in a dictionary, at the indicated place in its keys().
    
References
    [0] heapy_Use.html#heapykinds.Use.Via
    [1] heapy_UniSet.html#heapykinds.KindOfInViaFamilys~
findex( 0..*:kind: Kind+) -> (
    Subkind of: EquivalenceRelation[1]
    callable: (index: notnegative+)
        Calling the returned equivalence relation creates an
        equivalence class.
        Argument
            index: notnegative+
                The position of the matching kind in the sequence of
                kinds. The first one has index 0. Specifying the
                length of the sequence means that the equivalence
                class returned is the one where none of the kinds in
                the sequence matched.

    )

Create an equivalence relation based on a sequence of kinds. The
name is a combination of find and index. The classification of
each objects is done as follows:

For each kind in the sequence, check whether the object is an
element of that kind. If it is, the classification is the index
of that kind in the sequence. If the end of the sequence is
reached, the classification is the length of the sequence.
Argument
    kind: Kind+
        Each argument specifies the kind in that position in the
        sequence.
Bugs
    Though the Kind objects representing the equivalence classes
    work with set operations such as intersection and union, the
    tests such as subset and equality do not generally give the
    expected result.
References
    [0] heapy_Use.html#heapykinds.Use.findex
    [1] heapy_UniSet.html#heapykinds.EquivalenceRelationsq
idset(nodes: iterable+) -> IdentitySet[1]

Create a set of objects based on identity.

Argument
    nodes: iterable+
        The argument must be an iterable and may yield any kind
        of objects.
Note
    This method is the same as iso except for the argument.
References
    [0] heapy_Use.html#heapykinds.Use.idset
    [1] heapy_UniSet.html#heapykinds.IdentitySetsu
iso( 0..*:node: Any+) -> IdentitySet[1]

Create a set of objects based on identity.

Argument
    node: Any+
        Any kind of objects are valid arguments.
Note
    This method is the same as idset[2] except for the argument.
References
    [0] heapy_Use.html#heapykinds.Use.iso
    [1] heapy_UniSet.html#heapykinds.IdentitySet
    [2] heapy_Use.html#heapykinds.Use.idsett

(
R
(RRRRRRR(R	R
RRR
RRRRRRRRRRRRRRRRRRR (R!R
R"R#RR$RR%R&RRRRR'R(R)R*R+R,R-R.R/N(s_parent.Classifiers:Classs_parent.Classifiers:Clodos_parent.Classifiers:Ids_parent.Classifiers:Idsets_parent.Classifiers:Modules_parent.Classifiers:Rcss_parent.Classifiers:Sizes_parent.Classifiers:Types_parent.Classifiers:Unitys_parent.Classifiers:Vias_parent.Classifiers:findexs_parent.Classifiers:sonokinds_parent.Classifiers:tc_adapts_parent.Classifiers:tc_reprs_parent.Monitor:monitors_parent.Part:_load_stats_parent.Part:Stats_parent.Prof:pbs_parent.UniSet:Anythings_parent.UniSet:idsets_parent.UniSet:isos_parent.UniSet:Nothings_parent.UniSet:unions&_parent.UniSet:uniset_from_setcastables_parent:Views_parent.View:_hiding_tag_s_root.time:ctimes_root:warnings(0t__name__t
__module__t	_preload_t	_chgable_t_dir_t	_private_RR1R2R3R4R?RBRCt__str__RLROR%RRRRwR&R$R<RR'R(R)tFalseR t	_imports_t
_doc_Anythingt
_doc_Classt
_doc_Clodot_doc_Idt
_doc_Idsett_doc_Modulet_doc_Nothingt_doc_Rcst	_doc_Sizet	_doc_Typet
_doc_Unityt_doc_Viat_doc_findext
_doc_idsett_doc_isot_doc_sokind(((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyRs�










						
		(	a				



























'%(tguppy.etc.GlueRFRGtGluet	InterfaceR(((sB/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/Use.pyt<module>s