�
�d{Tc@
sdZd
dl
mZ
dZd
dlZd
dlZd
dlZd
dlZd
dl	m
Z
mZ
d
dlm
Z
mZmZ
d
dlmZ
d
dlmZ
d
d	lmZmZ
d
d
lmZ
d
dlmZ
d
dlmZ
d
ef
d��YZdef
d��YZdef
d��YZ def
d��YZ!e"d�
Z#e"d�
Z$de%f
d��YZ&de&f
d��YZ'de(f
d��YZ)e"d�
Z*de(f
d��YZ+ee+ed �
�
ee)ed!�
�
e"a,d"�Z-d#�Z.d$e%f
d%��YZ/d&�Z0iZ1d'�Z2d(e3f
d)��YZ4ee4�
d*e%f
d+��Y�
Z5d,e5f
d-��YZ6d.e6f
d/��YZ7d0e6f
d1��YZ8d2e5f
d3��YZ9d4e5f
d5��YZ:d
d6l;m<Z<
e<d7�
d8��
Z=e<d9�
d:��
Z>dS(;s:This module provides bases for predicates dispatching (the pattern in use
here is similar to what's refered as multi-dispatch or predicate-dispatch in the
literature, though a bit different since the idea is to select across different
implementation 'e.g. classes), not to dispatch a message to a function or
method. It contains the following classes:

* :class:`RegistryStore`, the top level object which loads implementation
  objects and stores them into registries. You'll usually use it to access
  registries and their contained objects;

* :class:`Registry`, the base class which contains objects semantically grouped
  (for instance, sharing a same API, hence the 'implementation' name). You'll
  use it to select the proper implementation according to a context. Notice you
  may use registries on their own without using the store.

.. Note::

  implementation objects are usually designed to be accessed through the
  registry and not by direct instantiation, besides to use it as base classe.

The selection procedure is delegated to a selector, which is responsible for
scoring the object according to some context. At the end of the selection, if an
implementation has been found, an instance of this class is returned. A selector
is built from one or more predicates combined together using AND, OR, NOT
operators (actually `&`, `|` and `~`). You'll thus find some base classes to
build predicates:

* :class:`Predicate`, the abstract base predicate class

* :class:`AndPredicate`, :class:`OrPredicate`, :class:`NotPredicate`, which you
  shouldn't have to use directly. You'll use `&`, `|` and '~' operators between
  predicates directly

* :func:`objectify_predicate`

You'll eventually find one concrete predicate: :class:`yes`

.. autoclass:: RegistryStore
.. autoclass:: Registry

Predicates
----------
.. autoclass:: Predicate
.. autofunc:: objectify_predicate
.. autoclass:: yes

Debugging
---------
.. autoclass:: traced_selection

Exceptions
----------
.. autoclass:: RegistryException
.. autoclass:: RegistryNotFound
.. autoclass:: ObjectNotFound
.. autoclass:: NoSelectableObject
i����(
tprint_functionsrestructuredtext enN(tlistdirtstat(tjointisdirtexists(
t	getLogger(
twarn(tstring_typest
add_metaclass(
tmodpath_from_file(
tset_log_methods(
t
classpropertytRegistryExceptionc
B
seZ
dZRS(
s"Base class for registry exception.(t__name__t
__module__t__doc__(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR
`s
tRegistryNotFoundc
B
seZ
dZRS(
saRaised when an unknown registry is requested.

    This is usually a programming/typo error.
    (RRR(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRcstObjectNotFoundc
B
seZ
dZRS(
svRaised when an unregistered object is requested.

    This may be a programming/typo or a misconfiguration error.
    (RRR(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRistNoSelectableObjectc
B
s eZ
dZd
�Zd�ZRS(s8Raised when no object is selectable for a given context.cC
s|
|_||_
||_dS(
N(targstkwargstobjects(tselfRRR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__init__qs
	
	
c

C
s d
|j|j
j�|jfS(Ns#args: %s, kwargs: %s
candidates: %s(RRtkeysR(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__str__vs

(RRRRR(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRos

	cC
s9t||
�}|d
dkr,|j
�
ndj|�
S(Ni����Rt
.(R
tpopR(tpatht	extrapathtmodpath((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt_modname_from_path{s



cC
s�|dkrigf}nx�|D]�}t
|�
r�tt|d
��
r�gt|�
D]}t||�^qV}t||
|�
q"|ddkr"t||
�}||d|<|dj||f�

q"q"W|S(sgReturn a dictionary of <modname>: <modpath> and an ordered list of
    (file, module name) to load
    s__init__.pyi����s.pyii
N(tNoneRRRR
t_toload_infoR tappend(RRt_toloadt	fileordirtfnametsubfilestmodname((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR"�s


!
(





tRegistrableObjectcB
s5eZ
dZdZdZdZeZe	d
��
Z
RS(s9This is the base class for registrable objects which are selected
    according to a context.

    :attr:`__registry__`
      name of the registry for this object (string like 'views',
      'templates'...). You may want to define `__registries__` directly if your
      object should be registered in several registries.

    :attr:`__regid__`
      object's identifier in the registry (string like 'main',
      'primary', 'folder_box')

    :attr:`__select__`
      class'selector

    Moreover, the `__abstract__` attribute may be set to True to indicate that a
    class is abstract and should not be registered.

    You don't have to inherit from this class to put it in a registry (having
    `__regid__` and `__select__` is enough), though this is needed for classes
    that should be automatically registered.
    c

C
s|jdkrd
S|jf
S(N((t__registry__R!(
tcls((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__registries__�s

N(RRRR!R*t	__regid__t
__select__tTruet__abstract__RR,(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR)�s


tRegistrableInstancec
B
seZ
dZd
�ZRS(s`Inherit this class if you want instances of the classes to be
    automatically registered.
    c
O
sEtt
|�j|�
}tjd
d�
dd}t|�
|_|S(szAdd a __module__ attribute telling the module where the instance was
        created, for automatic registration.
        tlimitii(tsuperR1t__new__ttbt
extract_stackR R(R+RRtobjtfilepath((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR4�s

(RRRR4(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR1�stRegistrycB
s�eZ
dZd
�Zd�Zed��
Zed��
Zd�Zde
d�Zd�Zd�Z
d	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�ZZZZZZRS(sThe registry store a set of implementations associated to identifier:

    * to each identifier are associated a list of implementations

    * to select an implementation of a given identifier, you should use one of the
      :meth:`select` or :meth:`select_or_none` method

    * to select a list of implementations for a context, you should use the
      :meth:`possible_objects` method

    * dictionary like access to an identifier will return the bare list of
      implementations for this identifier.

    To be usable in a registry, the only requirement is to have a `__select__`
    attribute.

    At the end of the registration process, the :meth:`__registered__`
    method is called on each registered object which have them, given the
    registry in which it's registered as argument.

    Registration methods:

    .. automethod: register
    .. automethod: unregister

    Selection methods:

    .. automethod: select
    .. automethod: select_or_none
    .. automethod: possible_objects
    .. automethod: object_by_id
    cC
s tt
|�j�
|
|_dS(
N(R3R9Rt	debugmode(RR:((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s

cC
sWytt
|�j|
�
SWn6tk
rR


t|
�
}tj�d
|_|�
n
XdS(s]return the registry (list of implementation objects) associated to
        this name
        i����N(R3R9t__getitem__tKeyErrorRtsystexc_infot
__traceback__(Rtnametexc((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR;�s





cC
sd
|
j|j
|
�
fS(s@returns a unique identifier for an object stored in the registrys%s.%s(Rtobjname(R+R7((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytobjid
scC
st|
d
t
|
�
�S(s<returns a readable name for an object stored in the registryR(tgetattrtid(R+R7((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRB
sc
C
sgxJ|j�D]<}
x3|
D]+}t
|d
d�}|r||�

qqWq
W|jrctt�

ndS(sWcall method __registered__() on registered objects when the callback
        is definedt__registered__N(tvaluesRDR!R:twrap_predicatest_lltrace(RRt	objectclst
registered((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytinitialization_completed

s





	
cC
sI|p|
j}|r&g}||<n|j
|g�}|j|
�

d
S(s,base method to add an object in the registryN(R-t
setdefaultR#(RR7toidtclearR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytregister
s

cC
s�t|t
�s!|j|�
}n|j|
jd�}xMt|�
D],\}}|j|�
|krC||=PqCqCW|jd
||
�
|j|
�

dS(s$remove <replaced> and register <obj>s3trying to replace %s that is not registered with %sN((t
isinstanceRRCtgetR-t	enumeratetwarningRP(RR7treplacedtregistered_objstindexRK((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytregister_and_replace&
s




	


cC
sv|j|
�
}|
j
}xW|j|d�D]0}|j|�
|kr+||j|�

Pq+q+W|jd
||�
dS(s&remove object <obj> from this registrys)can't remove %s, no id %s in the registryN((RCR-RRtremoveRT(RR7RCRNRK((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt
unregister9
s
	


	
c
C
s+g}
x|j�D]}|
|7}
qW|
S(
s?return a list containing all objects in this registry.
        (
RG(Rtresulttobjs((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytall_objectsG
s


cO
s||
}|d
||�S(s
return object with the `oid` identifier. Only one object is expected
        to be found.

        raise :exc:`ObjectNotFound` if there are no object with id `oid` in this
        registry

        raise :exc:`AssertionError` if there is more than one object there
        i((RRNRRR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytobject_by_idQ
s	
cO
sB|j||
||�
}|d
kr>t||||
��
n|S(s
return the most specific object among those with the given oid
        according to the given context.

        raise :exc:`ObjectNotFound` if there are no object with id `oid` in this
        registry

        raise :exc:`NoSelectableObject` if no object can be selected
        N(t_select_bestR!R(Rt_Registry__oidRRR7((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytselect^
s	


cO
s4y|j||
||�
SWnt
k
r/


d
SXd
S(s�return the most specific object among those with the given oid
        according to the given context, or None if no object applies.
        N(R_RR!(RR`RR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytselect_or_nonel
s



c
o
sGx@|j�D]2}|j
||
|�
}|d
kr:q
n|V
q
Wd
S(s^return an iterator on possible objects in this registry for the given
        context
        N(RGR_R!(RRRRR7((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytpossible_objectsu
s




c	O
s
d\}}xj|
D]b}|j
|||�
}||krM||g
}}q|d
kr||kr|j|�

qqW|dkr�dSt|�
dkr�d}|jr�t||||j�f�
�
n|j||||j��
n|j|d
||�S(s
return an instance of the most specific object according
        to parameters

        return None if not object apply (don't raise `NoSelectableObject` since
        it's costly when searching objects using `possible_objects`
        (e.g. searching for hooks).
        ii
s+select ambiguity: %s
(args: %s, kwargs: %s)N(iN(	R!R.R#tlenR:t	ExceptionRterrortselected(	RRRRtscoretwinnersR7tobjectscoretmsg((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR_
s










	"
cC
s
|
||�S(
sEoverride here if for instance you don't want "instanciation"
        ((RtwinnerRR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRg�
sc

O
sdS(
N(
R!(Rkt
atkw((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt<lambda>�
tN(RRRRR;tclassmethodRCRBRLR!tFalseRPRXRZR]R^RaRbRcR_RgtinfoRTRftcriticalt	exceptiontdebug(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR9�s" 
						
	
				
		c
C
s|
r
|
f
S|jS(
s5return a tuple of registry names (see __registries__)(
R,(R+tregistryname((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytobj_registries�
s

t
RegistryStorecB
s�eZ
dZed
�
Zd�Zd�Zi
ed6Z	d�Z
d�Zdd�
Zdded�Z
dd�
Zdd	�
Zdd
�
Zdd�
Zd�Zd
�Zd�Zd�Zd�Zdd�
Zed��
Zd�ZZZZZZRS(shThis class is responsible for loading objects and storing them
    in their registry which is created on the fly as needed.

    It handles dynamic registration of objects and provides a
    convenient api to access them. To be recognized as an object that
    should be stored into one of the store's registry
    (:class:`Registry`), an object must provide the following
    attributes, used control how they interact with the registry:

    :attr:`__registries__`
      list of registry names (string like 'views', 'templates'...) into which
      the object should be registered

    :attr:`__regid__`
      object identifier in the registry (string like 'main',
      'primary', 'folder_box')

    :attr:`__select__`
      the object predicate selectors

    Moreover, the :attr:`__abstract__` attribute may be set to `True`
    to indicate that an object is abstract and should not be registered
    (such inherited attributes not considered).

    .. Note::

      When using the store to load objects dynamically, you *always* have
      to use **super()** to get the methods and attributes of the
      superclasses, and not use the class identifier. If not, you'll get into
      trouble at reload time.

      For example, instead of writing::

          class Thing(Parent):
              __regid__ = 'athing'
              __select__ = yes()

              def f(self, arg1):
                  Parent.f(self, arg1)

      You must write::

          class Thing(Parent):
              __regid__ = 'athing'
              __select__ = yes()

              def f(self, arg1):
                  super(Thing, self).f(arg1)

    Controlling object registration
    -------------------------------

    Dynamic loading is triggered by calling the
    :meth:`register_objects` method, given a list of directories to
    inspect for python modules.

    .. automethod: register_objects

    For each module, by default, all compatible objects are registered
    automatically. However if some objects come as replacement of
    other objects, or have to be included only if some condition is
    met, you'll have to define a `registration_callback(vreg)`
    function in the module and explicitly register **all objects** in
    this module, using the api defined below.


    .. automethod:: RegistryStore.register_all
    .. automethod:: RegistryStore.register_and_replace
    .. automethod:: RegistryStore.register
    .. automethod:: RegistryStore.unregister

    .. Note::
        Once the function `registration_callback(vreg)` is implemented in a
        module, all the objects from this module have to be explicitly
        registered as it disables the automatic object registration.


    Examples:

    .. sourcecode:: python

       def registration_callback(store):
          # register everything in the module except BabarClass
          store.register_all(globals().values(), __name__, (BabarClass,))

          # conditionally register BabarClass
          if 'babar_relation' in store.schema:
              store.register(BabarClass)

    In this example, we register all application object classes defined in the module
    except `BabarClass`. This class is then registered only if the 'babar_relation'
    relation type is defined in the instance schema.

    .. sourcecode:: python

       def registration_callback(store):
          store.register(Elephant)
          # replace Babar by Celeste
          store.register_and_replace(Celeste, Babar)

    In this example, we explicitly register classes one by one:

    * the `Elephant` class
    * the `Celeste` to replace `Babar`

    If at some point we register a new appobject class in this module, it won't be
    registered at all without modification to the `registration_callback`
    implementation. The first example will register it though, thanks to the call
    to the `register_all` method.

    Controlling registry instantiation
    ----------------------------------

    The `REGISTRY_FACTORY` class dictionary allows to specify which class should
    be instantiated for a given registry name. The class associated to `None`
    key will be the class used when there is no specific class for a name.
    cC
s tt
|�j�
|
|_dS(
N(R3RyRR:(RR:((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR"s

c
C
s.x|j�D]}
|
j
�
q
Wi|_d
S(s*clear all registries managed by this storeN(RGROt_lastmodifs(Rtsubdict((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytreset&s

cC
sWytt
|�j|
�
SWn6tk
rR


t|
�
}tj�d
|_|�
n
XdS(sZreturn the registry (dictionary of class objects) associated to
        this name
        i����N(R3RyR;R<RR=R>R?(RR@RA((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR;-s





cC
s/y|j|
SWnt
k
r*


|jd
SXd
S(sWreturn existing registry named regid or use factory to create one and
        return itN(tREGISTRY_FACTORYR<R!(Rtregid((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytregistry_class=s



cC
sEy||
SWn2tk
r@


|j
|
�
|j�
||
<||
SXdS(
N(RRR:(RR~((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRMEs






cC
stxm|
D]e}|j|�
r|j
|kr||krt|t�r\|j|||�
ql|j|�

qqWd
S(s~register registrable objects into `objects`.

        Registrable objects are properly configured subclasses of
        :class:`RegistrableObject`.  Objects which are not defined in the module
        `modname` or which are in `butclasses` won't be registered.

        Typical usage is:

        .. sourcecode:: python

            store.register_all(globals().values(), __name__, (ClassIWantToRegisterExplicitly,))

        So you get partially automatic registration, keeping manual registration
        for some object (to use
        :meth:`~logilab.common.registry.RegistryStore.register_and_replace` for
        instance).
        N(tis_registrableRRQttypet_load_ancestors_then_objectRP(RRR(t
butclassesR7((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytregister_allLs


*

cC
s�x�t|
|�D]{}|j
|�
}|j|
d
|d|�

|jd|j|
�
||pb|
j�
|
|jj
|
ji�|j|
�
<qWdS(s
register `obj` implementation into `registryname` or
        `obj.__registries__` if not specified, with identifier `oid` or
        `obj.__regid__` if not specified.

        If `clear` is true, all objects with the same identifier will be
        previously unregistered.
        RNROsregister %s in %s['%s']N(	RxRMRPRvRBR-t_loadedmodsRRC(RR7RwRNROtregistry((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRPgs	


	

cC
sWxPt|
|�D]?}||}|j
|
�

|jd
|j|
�
||
j�
qWdS(ssunregister `obj` object from the registry `registryname` or
        `obj.__registries__` if not specified.
        sunregister %s from %s['%s']N(RxRZRvRBR-(RR7RwR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRZws





	
cC
sfx_t|
|�D]N}||}|j
|
|�
|jd
|j|
�
||
j|j|�
�
qWdS(s�register `obj` object into `registryname` or
        `obj.__registries__` if not specified. If found, the `replaced` object
        will be unregistered first (else a warning will be issued as it is
        generally unexpected).
        s%register %s in %s['%s'] instead of %sN(RxRXRvRBR-(RR7RURwR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRX�s



	

cC
s/|j�
t
|
|�\|_}i|_|S(
sbreset registry and walk down path to return list of (path, name)
        file modules to be loaded(R|R"t_toloadmodsR�(RRRtfilemods((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytinit_registration�s
	
cC
sG|j|
|�}x$|D]\}}|j
||�
qW|j�
d
S(s.register all objects found walking down <path>N(R�t	load_fileRL(RRRR�R8R(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytregister_objects�s


c
C
s%x|j�D]}
|
j
�
q
Wd
S(s7call initialization_completed() on all known registriesN(RGRL(Rtreg((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRL�s
cC
s;yt|
�
d
SWn"t
k
r6


|jd|
�
dSXdS(s- return the modification date of a file path i����s3Unable to load %s. It is likely to be a backup fileN(RtOSErrorRTR!(RR8((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt_mdate�s


	

cC
s�|j}x�|
D]�}t
|�
rott|d
��
ro|jgt|�
D]}t||�^qJ�
r�tSq|ddkr|j|�
}|dkr�qnd|kr�qn||ks�|||kr�|j	d|�
tSqqWt
S(s\return True if something module changed and the registry should be
        reloaded
        s__init__.pyi����s.pytflymakes File %s changed since last visitN(RzRRRtis_reload_neededR
R/R�R!RsRr(RRt
lastmodifsR%R&tmdate((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s 	


!
	
(









cC
s�d
dlm
}
||jkr#dSi|j|<|j|
�
}|dkrOdSd|
kr_dS||j|
<||�
}|j|�

dS(s6 load registrable objects (if any) from a python file i����(
tload_module_from_nameNR�(tlogilab.common.modutilsR�R�R�R!Rztload_module(RR8R(R�R�tmodule((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s









cC
s[|jd
|
j
|
j�
t|
d�r8|
j|�

n|jt|
�
j�|
j
�
dS(s\Automatically handle module objects registration.

        Instances are registered as soon as they are hashable and have the
        following attributes:

        * __regid__ (a string)
        * __select__ (a callable)
        * __registries__ (a tuple/list of string)

        For classes this is a bit more complicated :

        - first ensure parent classes are already registered

        - class with __abstract__ == True in their local dictionary are skipped

        - object class needs to have registries and identifier properly set to a
          non empty string to be registered.
        sloading %s from %stregistration_callbackN(RsRt__file__thasattrR�R�tvarsRG(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s

cC
s]
t|t
�sA|j|�
r=|j|
kr=|j|�

nd
S|j}||
kr�||jkr|j|j||�
nd
Sd|
|jf}||j|
kr�d
S||j|
|<x$|j	D]}|j
|
||�
q�W||ks

|j|�
r
d
S|jt|�
d�
}|j
|�
ddkrL
td|t�
d
S|j|�

d
S(s\handle class registration according to rules defined in
        :meth:`load_module`
        Ns%s.%sit
_sx[lgc 0.59] object whose name start with '_' won't be skipped anymore at some point, use __abstract__ = True instead (%s)(RQR�R�RRPR�R�RR�t	__bases__R�RMRxRBRtDeprecationWarning(RR(RJR�t
objmodnametclsidtparentR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s.


	









cC
s
t|
t
�rqt|
t�s[t|
d
d�oQt|
dd�oQt|
dd�sntSq�t|
t�r�tSnt|
t�s�tS|
js�tS|
j	}|s�tS|
j
}|s�tS|
jjdt�r�tSt|t
tf�s�|jd|
�
tSt|�
s
|jd|
�
tStS(s�ensure `obj` should be registered

        as arbitrary stuff may be registered, do a lot of check and warn about
        weird cases (think to dumb proxy objects)
        R,R-R.R0s2%s has __registries__ which is not a list or tuples%s has not callable __select__N(RQR�t
issubclassR)RDR!RrR1R-R,R.t__dict__RRttupletlistRTtcallableR/(R+R7t
registriestselector((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�!s6








	

	


	









c

O
sdS(
N(
R!(RkRmRn((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRoHRpN((( RRRRrRR|R;R9R!R}RRMR�RPRZRXR�R�RLR�R�R�R�R�RqR�RsRTRfRtRuRv(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRy�
s*u		
		

			
			)'sregistry.storeR�cC
sI|d
}tdks%|j
tkrEtd||||j
f�

ndS(Nitalls%s -> %s for %s(%s)(tTRACED_OIDSR-tprint(R+R�Rtrettvobj((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt_trace_selectorSs



c

s+�f
d
�}
�j|
_�j
|
_
|
S(sfuse this decorator on your predicates so they become traceable with
    :class:`traced_selection`
    c

s8�||
|�
}tdk	r4t|�|
|�
n|S(
N(R�R!R�(R+RRR�(
R�(sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyttraced\s



(RR(R�R�((
R�sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRIXs

ttraced_selectioncB
s,eZ
dZd
d�
Zd�Zd�ZRS(s
    Typical usage is :

    .. sourcecode:: python

        >>> from logilab.common.registry import traced_selection
        >>> with traced_selection():
        ...     # some code in which you want to debug selectors
        ...     # for all objects

    This will yield lines like this in the logs::

        selector one_line_rset returned 0 for <class 'elephant.Babar'>

    You can also give to :class:`traced_selection` the identifiers of objects on
    which you want to debug selection ('oid1' and 'oid2' in the example above).

    .. sourcecode:: python

        >>> with traced_selection( ('regid1', 'regid2') ):
        ...     # some code in which you want to debug selectors
        ...     # for objects with __regid__ 'regid1' and 'regid2'

    A potentially useful point to set up such a tracing function is
    the `logilab.common.registry.Registry.select` method body.
    R�cC
s
|
|_dS(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s
c


C
s
|ja
dS(
N(R�R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt	__enter__�scC
sda
|dkS(
N(R!R�(RtexctypeRAt	traceback((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__exit__�s
(RRRRR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�es	c


s0t�j
tf
i�jd
6�f
d�d6�S(sX
Most of the time, a simple score function is enough to build a selector.
    The :func:`objectify_predicate` decorator turn it into a proper selector
    class::

        @objectify_predicate
        def one(cls, req, rset=None, **kwargs):
            return 1

        class MyView(View):
            __select__ = View.__select__ & one()

    Rc

s
�|
|�S(
N((RRmRn(
t
selector_func(sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRo�Rpt__call__(R�Rt	PredicateR(
R�((
R�sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytobjectify_predicate�s



c
C
spxitj
�D][}
d
|
jkr1t�|
_n||
jkrFq
n|
jj|�

||
j�
|
_q
WdS(Nt_decorators(t_PREDICATESRGR�tsetR�taddR�(t	decoratort	predicate((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRH�s






tPredicateMetaClassc
B
seZ
d�ZRS(
c
O
s>tj
||
|�
}tj|d
��}|tt|�
<|S(Nc

S
stj
t|�
�
S(
N(R�RRE(
t
p((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRo�Rp(R�R4tweakreftproxyR�RE(tmcsRRtinstR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR4�s


(RRR4(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s
R�cB
s�eZ
dZed
��
Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�ZRS(
s�base class for selector classes providing implementation
    for operators ``&``, ``|`` and  ``~``

    This class is only here to give access to binary operators, the selector
    logic itself should be implemented in the :meth:`__call__` method. Notice it
    should usually accept any arbitrary arguments (the context), though that may
    vary depending on your usage of the registry.

    a selector is called to help choosing the correct object for a
    particular context by returning a score (`int`) telling how well
    the implementation given as first argument fit to the given context.

    0 score means that the class doesn't apply.
    c


C
s
|jj
S(
N(t	__class__R(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt	func_name�scC
sE||
kr|St|
t
�s.t|
t�rAt||
�rA|Sd
S(s�search for the given selector, selector instance or tuple of
        selectors in the selectors tree. Return None if not found.
        N(RQR�R�R!(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytsearch_selector�s




c


C
s
|jj
S(
N(R�R(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s
cC
s
t||
�S(
N(
tAndPredicate(Rtother((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__and__�s
cC
s
t|
|�S(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__rand__�s
cC
s
t||
�S(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__iand__�s
cC
s
t||
�S(
N(
tOrPredicate(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__or__�s
cC
s
t|
|�S(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__ror__�s
cC
s
t||
�S(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__ior__�s
c

C
s
t|�
S(
N(
tNotPredicate(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt
__invert__�s
cO
std
|j
�
S(Ns;selector %s must implement its logic in its __call__ method(tNotImplementedErrorR�(RR+RR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s

c

C
sd
|jj
t|�
fS(Nu<Predicate %s at %x>(R�RRE(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt__repr__�s
(RRRtpropertyR�R�RR�R�R�R�R�R�R�R�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s										tMultiPredicatecB
s8eZ
dZd
�Zd�Zed��
Zd�ZRS(s(base class for compound selector classesc
G
s|j|
�
|_
dS(
N(tmerge_selectorst	selectors(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s
c

C
s*d
|jj
djd�|jD�
�
fS(Ns%s(%s)t
,c
s
s|]}
t|
�
V
qdS(
N(
tstr(t.0t
s((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pys	<genexpr>�s(R�RRR�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s

cC
s�g}x�|
D]�}t|t
j�r7t|�
�}nt|t�rat|t�ra|�}nt||�r�||j7}q
|j|�

q
W|S(
s�deal with selector instanciation when necessary and merge
        multi-selectors if possible:

        AndPredicate(AndPredicate(sel1, sel2), AndPredicate(sel3, sel4))
        ==> AndPredicate(sel1, sel2, sel3, sel4)
        (	RQttypestFunctionTypeR�R�R�R�R�R#(R+R�tmerged_selectorsR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s






cC
sYx@|jD]5}||
kr |S|j
|
�
}|d
k	r
|Sq
Wtt|�j
|
�
S(s�search for the given selector or selector instance (or tuple of
        selectors) in the selectors tree. Return None if not found
        N(R�R�R!R3R�(RR�t
childselectortfound((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�s




(RRRRRRqR�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR��s

		R�c
B
seZ
dZd
�ZRS(sand-chained selectorscO
sDd
}x7|jD],}||
||�
}|s2d
S||7}qW|S(Ni(
R�(RR+RRRhR�t	partscore((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�$s






(RRRR�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�"s

R�c
B
seZ
dZd
�ZRS(sor-chained selectorscO
s4x-|jD]"}||
||�
}|r
|Sq
Wd
S(Ni(
R�(RR+RRR�R�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�0s





(RRRR�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�.s

R�c
B
s)eZ
dZd
�Zd�Zd�ZRS(snegation selectorcC
s
|
|_dS(
N(
R�(RR�((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR9s
cO
s |j|
||�
}t
|�
S(
N(R�tint(RR+RRRh((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�<s

c

C
sd
|jS(NsNOT(%s)(
R�(
R((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR@s
(RRRRR�R(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�7s

		tyescB
s#eZ
dZd
d�
Zd�ZRS(s$
Return the score given as parameter, with a default score of 0.5 so any
    other selector take precedence.

    Usually used for objects which can be selected whatever the context, or
    also sometimes to add arbitrary points to a score.

    Take care, `yes(0)` could be named 'no'...
    g�?cC
s
|
|_dS(
N(
Rh(RRh((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyRMs
c

O
s|jS(
N(
Rh(RRR((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�Ps
(RRRRR�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyR�Ds
(
t
deprecateds2[lgc 0.59] use Registry.objid class method insteadc

C
sd
|j|j
fS(Ns%s.%s(RR(
R+((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytclassidXss.[lgc 0.59] use obj_registries function insteadcC
s
t||
�S(
N(
Rx(R+Rw((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pytclass_registries\s(?Rt
__future__Rt
__docformat__R=R�R�R�R5tosR
Rtos.pathRRRtloggingRtwarningsRtsixRR	R�R
tlogilab.common.logging_extRtlogilab.common.decoratorsRReR
RRRR!R R"tobjectR)R1tdictR9RxRyR�R�RIR�R�R�RHR�R�R�R�R�R�R�R�tlogilab.common.deprecationR�R�R�(((sH/opt/alt/python27/lib/python2.7/site-packages/logilab/common/registry.pyt<module>Js\








$���
		
*				
=/