c&XUdZdZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z m Z mZddlmZmZmZmZmZddlmZddlmZdd lmZmZmZmZmZdd lmZej>d k\rdd lm Z dd l!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(dedefdZ)iZ*ee+efe,d<deddfdZ-Gdde.Z/Gdde0e/Z1Gdde1Z2Gdde2Z3Gd d!e2Z4Gd"d#e1Z5Gd$d%e1Z6e(d&d'Z7e(d(d)Z8Gd*d+e9Z:Gd,d-e:Z;Gd.d/e:Z<Gd0d1e:Z=Gd2d3e:Z>dLd4e?d5eede?fd6Z@ dLd4ee?d5eed7eeee?e?fefdeee?e?feee?e?fffd8ZAGd9d:e0ZBGd;dd k\re d=ee+eeed>eed>d?ZDnee?eee+eed>effZDGd@d>eEZFdLdAedBeedee?fdCZGGdDdEeEZHe$eHedFe$eFedGdaIdHZJdIZKGdJdKe0ZLy)MaThis 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 .. autofunction:: objectify_predicate .. autoclass:: yes .. autoclass:: AndPredicate .. autoclass:: OrPredicate .. autoclass:: NotPredicate Debugging --------- .. autoclass:: traced_selection Exceptions ---------- .. autoclass:: RegistryException .. autoclass:: RegistryNotFound .. autoclass:: ObjectNotFound .. autoclass:: NoSelectableObject zrestructuredtext enN)listdirstat)joinisdirexists)DictTypeOptionalUnionSequence) getLogger)warn)ListTupleAnyIterableCallable) ModuleType)) TypedDict)modpath_from_file)set_log_methods) classproperty)callable_deprecated selector_funcreturnc\tjtfjfddS)aXMost 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() c|i|SN)selfakwrs 9/usr/lib/python3/dist-packages/logilab/common/registry.pyz%objectify_predicate..s}a/F2/F)__doc____call__)type__name__ Predicater()rs`r%objectify_predicater-ns1   $,,F  r' _PREDICATES decoratorctjD]`}d|jvrt|_||jvr/|jj |||j |_by)N _decorators)r.values__dict__setr1addr))r/ predicates r%wrap_predicatesr7sj '');  2 2 2$'EI !  -- - !!),&y'9'9:  ;r'ceZdZdZy)PredicateMetaClassctj|g|i|}tj|d}|tt |<|S)Nc>tjt|Sr )r.popid)ps r%r&z,PredicateMetaClass.__new__..skoobe.Dr')r*__new__weakrefproxyr.r=)mcsargskwargsinstrAs r%r?zPredicateMetaClass.__new__s>||C1$1&1 d$DE!& BuI r'N)r+ __module__ __qualname__r?r!r'r%r9r9sr'r9c~eZdZdZedZdddedfdZdZddZ ddZ dd Z dd Z dd Z dd Zd ZdZdZy)r,abase 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.|jjSr  __class__r+r"s r% func_namezPredicate.func_names~~&&&r'selectorrcl||ur|St|tst|trt||r|Sy)zsearch for the given selector, selector instance or tuple of selectors in the selectors tree. Return None if not found. N) isinstancer*tupler"rNs r%search_selectorzPredicate.search_selectors; 8 K x &*Xu*E: (L Kr'c.|jjSr rJrLs r%__str__zPredicate.__str__s~~&&&r'ct||Sr  AndPredicater"others r%__and__zPredicate.__and__D%((r'ct||Sr rWrYs r%__rand__zPredicate.__rand__sE4((r'ct||Sr rWrYs r%__iand__zPredicate.__iand__r\r'ct||Sr  OrPredicaterYs r%__or__zPredicate.__or__4''r'ct||Sr rbrYs r%__ror__zPredicate.__ror__s5$''r'ct||Sr rbrYs r%__ior__zPredicate.__ior__rer'ct|Sr ) NotPredicaterLs r% __invert__zPredicate.__invert__s D!!r'c2td|jzS)Nz;selector %s must implement its logic in its __call__ method)NotImplementedErrorrK)r"clsrCrDs r%r)zPredicate.__call__s" Lt~~ ]  r'cJd|jjt|fzS)Nz)rKr+r=rLs r%__repr__zPredicate.__repr__s %)@)@"T((KKKr'N)rZr,rrX)rZr,rrc)rZr,)r+rFrGr(propertyrMr rSrUr[r^r`rdrgrirlr)rqr!r'r%r,r,sf ''  8M ')))((("  Lr'r,) metaclasscneZdZdZdeddfdZdZedee de e fdZ de de e ffd Z xZS) MultiPredicatez(base class for compound selector classes selectorsrNc0|j||_yr )merge_selectorsrv)r"rvs r%__init__zMultiPredicate.__init__s--i8r'cz|jjddjd|jDdS)N(,c32K|]}t|ywr )str).0ss r% z)MultiPredicate.__str__..s<\SV<\s))rKr+rrvrLs r%rUzMultiPredicate.__str__s*>>22CHH<\T^^<\4\]]r'cBg}|D]}t|tjrt|}t|trt |t r|}t|t sJ|t||r||jz }|j||S)zdeal with selector instanciation when necessary and merge multi-selectors if possible: AndPredicate(AndPredicate(sel1, sel2), AndPredicate(sel3, sel4)) ==> AndPredicate(sel1, sel2, sel3, sel4) ) rPtypes FunctionTyper-r* issubclassr,rvappend)rorvmerged_selectorsrNs r%rxzMultiPredicate.merge_selectorss! 2H(E$6$678.x8:(D)j9.M#:h 2 : and an ordered list of (file, module name) to load N __init__.py.pyr) rPlistrrrr _toload_inforr)rrr fileordirfnamesubfilesmodnames r%rrs $%%%b& 4  tI}'E FG"+GAJw  AJ  y'2 3 4 NPs B%c~eZdZUdZdZeeed<dZeeed<dZ e dee fed<dZ e de eeeffdZy) RegistrableObjecta9This 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. N __registry__ __regid__ __select__Trc6|jy|jfS)Nr!)rrs r%__registries__z RegistrableObject.__registries__s    #  ""r')r+rFrGr(rr r~__annotations__rrr r, __abstract__rrrr!r'r%rrsg.#'L(3-&#Ix}#.2JdC*+2L#uU3Z%67##r'rc>eZdZdZfdZddeeddffd ZxZS)RegistrableInstancez`Inherit this class if you want instances of the classes to be automatically registered. c|jdd}tt||}|Wt dj |j ttjddd}t||_ |S||_ |S)zzAdd a __module__ attribute telling the module where the instance was created, for automatic registration. rFNz'instantiate {} with __module__=__name__)limitr) r<rrr?rformatr+DeprecationWarningtb extract_stackrrF)rorCrDmoduleobjfilepathrKs r%r?zRegistrableInstance.__new__sL$/'5c: > <CCCLLQ"  ''a03A6H/9CN $CN r'NrFrc*tt| yr )rrry)r"rFrKs r%ryzRegistrableInstance.__init__s !413r'r ) r+rFrGr(r?r r~ryrrs@r%rrs)$48C=4D44r'rSelectBestReportRegistry) all_objects end_scorewinnerswinnerr"rCrDregistryc eZdZdZdeddffd ZfdZedede fdZ edede fd Z dd Z dded e ed eddfd ZdZdZdZdZdZdZdZdZdZdZdxZxZxZxZxZZxZS)raThe 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 debugmoderNcFtt| ||_g|_yr )rrryr_select_listenersr"rrKs r%ryzRegistry.__init__s h&("KMr'c tt| |S#t$r*t |}t j d|_|wxYw)z]return the registry (list of implementation objects) associated to this name r)rr __getitem__KeyErrorrsysexc_info __traceback__r"nameexcrKs r%rzRegistry.__getitem__sK 44T: :  &C # r 2C I  3A rcB|jd|j|S)z@returns a unique identifier for an object stored in the registryr)rFobjnamerors r%objidzRegistry.objid(s..#++c*:;;r'c.t|dt|S)z> H % r'oidclearcd|jvsJ||jsJ||xs |j}|s Jd|z|rgx}||<n|j|g}||vs Jd|z|j |y)z,base method to add an object in the registryrzKno explicit name supplied to register object %s, which has no __regid__ setzobject %s is already registeredN)r3rr setdefaultr)r"rrr rs r%registerzRegistry.register=sS\\16361~~"s"~"S]] \_b b s "$ $Gd3iooc2.G'!J#Ds#JJ!sr'c:t|ts|j|}||us Jd|z|j|jd}t |D]\}}|j||k(s||=n|j d|||j|y)z$remove and register z!replacing an object by itself: %sr!z3trying to replace %s that is not registered with %sN)rPr~rgetr enumeratewarningr )r"rreplacedregistered_objsindexrs r%register_and_replacezRegistry.register_and_replaceLs (C(zz(+H("M$G#$MM"((3=="5!*?!; _ E:zz*%1#E* _ LLNPXZ] ^ cr'c|j|}|j}|j|dD],}|j||k(s||j|y|j d||y)z&remove object from this registryr!z)can't remove %s, no id %s in the registryN)rrrremover)r"rrrrs r% unregisterzRegistry.unregister^so 3mm((3+ RJzz*%.S   ,  R LLDeS Qr'c>g}|jD]}||z } |S)z6return a list containing all objects in this registry.)r2)r"resultobjss r%rzRegistry.all_objectsks*KKM D dNF  r'cL||}t|dk(sJ||d|i|S)areturn 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 rr)len)r"rrCrDrs r% object_by_idzRegistry.object_by_idts:s)7|q )') wqz4*6**r'c\|j||g|i|}|t|||||S)areturn 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 ) _select_bestr)r"_Registry__oidrCrDrs r%selectzRegistry.selectsA dU =d=f= ;$T64;? ? r'cT |j||g|i|S#t$rYywxYw)zreturn the most specific object among those with the given oid according to the given context, or None if no object applies. N)rr)r"r rCrDs r%select_or_nonezRegistry.select_or_nones: $4$$T%[B4B6B B  s  ''c/pK|jD]}|j|g|i|}||!yw)z^return an iterator on possible objects in this registry for the given context N)r2r)r"rCrDrrs r%possible_objectszRegistry.possible_objectssF{{} G#$##G=d=f=C{I  s46c:|jj|y)a{ Add a listener to the list of one parameters callables (function/method) that will be called everytime the selection Registry._select_best is done and they will recieve a dict of the following form:: {"all_objects": [], "end_score": 0, "winners": [], "winner": None or winner, "self": self, "args": args, "kwargs": kwargs, } N)rr)r"listeners r%add_select_best_listenerz!Registry.add_select_best_listeners %%h/r'c |jr |gdgd|||d}d\}}|D]c}|j|g|i|}|jrdj||d||kDr||g}}G|dkDsM||k(sS|j|e|jrA|r|jngd<|r|dn||d<||d <|jD] } | | |yt |d kDrOd } |j rt | |||jfz|j| |||j|j|d||S) aQreturn 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). Every callable stored in Registry._select_listeners will be called once the selection is done and will recieve a dict of the following form:: {"all_objects": [], "end_score": 0, "winners": [], "winner": None or winner, "self": self, "args": args, "kwargs": kwargs, "registry": self} rN)rrrrrr"rCrD)rNr)objectrrrrrz+select ambiguity: %s (args: %s, kwargs: %s)) rrrcopyrrrrerrorselected) r"rrCrDselect_best_reportrrr objectscorer'msgs r%rzRegistry._select_bests|  ! ! !  4 !w $C(#..>t>v>K%%"=188CR]9^_U"!,sewq[E%9s# $  ! !>EGLLN2 y )9@71:g x (.3 { + 22 -+, - ? wr'rN)NF) r+rFrGr(boolryrrrr~rrrr r rrrrr!r#r%r(rr-inforr,critical exceptiondebugrrs@r%rrsBN$N4N <<<<1#1#11 & C hsm 4 TX $ R +  0=7~' =WVDV7VUVXV Er'rorc$|r|fS|jS)z5return a tuple of registry names (see __registries__))rrs r%rrs   r'c eZdZUdZd*deddffd Zd+dZdedeffd Z deiZ e e defe fed <d ede fd Zd edefd Zd,d edededdfdZ d-dedeedeededdf dZd.dZd.dZ d.deedeedeeeeffdZedd.deedeeddfdZdeeddfdZd+dZd edee fd!Z!d"Z"d ededdfd#Z#d$e$ddfd%Z% d,ded&e deeddfd'Z&e'dedefd(Z(d)xZ)xZ*xZ+xZ,xZ-Z.xZ/S)/ RegistryStoreaVThis 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_modnames` method, given a list of modules names to inspect. .. automethod:: register_modnames 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. rrNc8tt| ||_yr )rr=ryrrs r%ryzRegistryStore.__init__rs mT+-"r'c\|jD]}|ji|_y)z*clear all registries managed by this storeN)r2r  _lastmodifs)r"subdicts r%resetzRegistryStore.resetvs*{{} G MMO +-r'rc tt| |S#t$r*t |}t j d|_|wxYw)zZreturn the registry (dictionary of class objects) associated to this name r)rr=rrrrrrrs r%rzRegistryStore.__getitem__}sK 9$? ? "4(C # r 2C I rREGISTRY_FACTORYregidc^ |j|S#t$r|jdcYSwxYw)zWreturn existing registry named regid or use factory to create one and return itN)rDrr"rEs r%registry_classzRegistryStore.registry_classs8 /((/ / /((. . /s ,,c~ ||S#t$r,|j||j||<||cYSwxYwr )rrHrrGs r%r zRegistryStore.setdefaultsI ;  4$--e4T^^DDK;  s 2<<rr butclassesct|ts Jd|z|D]^}|j|s|j|k(s%||vs*t|tr|j |||N|j |`y)a~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). z8modname expected to be a module name (ie string), got %rN)rPr~is_registrablerFr*_load_ancestors_then_objectr )r"rrrJrs r% register_allzRegistryStore.register_alls}$'3' F P ' 'C""3'CNNg,E#U_J_c4(44Wc:NMM#&  'r'rrrr c|jjdrJ|t||D]}|j|}|j ||||j d|j |||xs |j||jj|ji|j|<y)aregister `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. r)rr zregister %s in %s['%s']N) r3rrr r r:rr _loadedmodsrFr)r"rrrr rs r%r zRegistryStore.registers<<##N38S83*3 = WL|4H   cs%  8 JJ)8+;+;C+@,PSPdWZWdWd TWD   ' ' ;HNN3N)rV load_filer)r"rrrUrrs r%register_objectszRegistryStore.register_objectssD ))$ :!) . Hg NN8W - . %%'r'modnamescX|ji|_i|_g}|D]Y}tj|}|J|j }|dddvr|dd}||j|<|j ||f[|D]\}}|j|||jy)z(register all objects found in N)z.pycz.pyor) rBrPrTpkgutil find_loader get_filenamerrXr)r"rZtoloadrloaderrs r%register_modnameszRegistryStore.register_modnamess  /G((1F% %%**,H} 00#CR=(0D  W % MM8W- . /"( . Hg NN8W - . %%'r'cN|jD]}|jy)z7call initialization_completed() on all known registriesN)r2r)r"regs r%rz&RegistryStore.initialization_completeds#;;= +C  ( ( * +r'rcb t|dS#t$r|jd|YywxYw)z+return the modification date of a file pathz3Unable to load %s. It is likely to be a backup fileN)rOSErrorr)r"rs r%_mdatezRegistryStore._mdate"s8 >"% %  LLNPX Y s ..c b|j}|D]}t|rJtt|dr5|j t |Dcgc]}t||c}sVy|dddk(sa|j |}|ud|vrz||vs |||ks|jd|yycc}w) z\return True if something module changed and the registry should be reloaded rTrNrflymakez File %s changed since last visitF)r@rrris_reload_neededrrhr7)r"r lastmodifsrrmdates r%rkzRegistryStore.is_reload_needed+s%%  IYF4 =+I$J((gV_N`)aU$y%*@)ab235( I.=)+J.*Y2G%2OII@)L *bs B, cL||jvryi|j|<|j|}|yd|vry||j|<tjdkrt |t s t |}t||jddd}|j|y)z4load registrable objects (if any) from a python fileNrj)rrr)fromlist) rPrhr@r version_inforPr~ __import__split load_module)r"rrrmrs r%rXzRegistryStore.load_file@s d&& & $&! H% =  ( " &+"   d ":gs+C'lGGgmmC.@".EF  r'rc|jd|j|jt|dr|j |y|j t |j|jy)a\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. zloading %s from %sregistration_callbackN)r7r+__file__hasattrrurNvarsr2)r"rs r%rszRegistryStore.load_moduleUsY& &I 62 3  ( ( .   d6l113V__ Er'rct|ts2|j|r |j|k(r|j |y|j}||k7r.||j vr|j |j ||y|d|j}||j|vry||j||<|jD]}|j|||||vs|j|sy|jt|d}|j|ddk(rtd|zty|j |y)z\handle class registration according to rules defined in :meth:`load_module` Nrr_zx[lgc 0.59] object whose name start with '_' won't be skipped anymore at some point, use __abstract__ = True instead (%s))rPr*rLrFr rTrXr+rP __bases__rMr rrrr)r"rrrJ objmodnameclsidparentrds r%rMz)RegistryStore._load_ancestors_then_objectpsP)T*""9-)2F2F'2Q i( ))  T---t// ;ZH "I$6$67 D$$W- - +4!%()) JF  , ,Wfj I J  "$*=*=i*H oonY7:; ;;y !! $ + !*+#    i r'ct|trIt|ts(t |ddrt |ddr t |dds#yt|t ryt|t sy|j sy|j}|sy|j}|sy|jjddryt|ttfs|jd|yt|s|jd|yy ) zensure `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) rNrrFrz2%s has __registries__ which is not a list or tuplez%s has not callable __select__T)rPr*rrrrrrrr3rrQrrcallable)ror registriesrNs r%rLzRegistryStore.is_registrables c4 c#45C!148[$7\48 C!45C!45}}'' >> <<  NE 2*udm4 KKLc R! KK8# >r'cyr r!r3s r%r&zRegistryStore.r4r')Fr5)r!)NNFr )0r+rFrGr(r6ryrBr~rrrDrr r*rrHr rr rNrr r rrrrrVrrYrbrrrhrkrXrrsrMrrLr7rr,r8r9r:rrs@r%r=r=sFsj#$#4#.   7;H5Ed5s+T12E/C/D/'H's''Z^'>'+! W WsmWc] W  W  W. (;? I *23-  eCHo  :;(T#Y(8C=(TX(<(($s)((*+ sx}*!#!!!*F*FF8JL,!,!'+,!9A#,! ,!\,,,,`=WVDV7VUVXV Er'r=zregistry.storerc |d}tdk(s|jtvr"t|d|d|d|jdyy)Nrallz -> z for r{r) TRACED_OIDSrprint)rorNrCretvobjs r%_trace_selectorrs8 7Det~~< sCt~~FG =r'cVfd}j|_j|_|S)zfuse this decorator on your predicates so they become traceable with :class:`traced_selection` cH|g|i|}tt||||Sr )rr)rorCrDrrNs r%tracedz_lltrace..traceds0s,T,V,  " C4 5 r')r+r()rNrs` r%rrs)  ''FO%%FN Mr'c$eZdZdZddZdZdZy)traced_selectiona 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 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. c||_yr )r)r"rs r%ryztraced_selection.__init__ s  r'c|jayr )rrrLs r% __enter__ztraced_selection.__enter__s kk r'cda|duSr )r)r"exctyper tracebacks r%__exit__ztraced_selection.__exit__s D  r'N)r)r+rFrGr(ryrrr!r'r%rrs6"!r'rr )Mr( __docformat__rr]rr@rrosrros.pathrrrtypingrr r r r loggingr warningsrrrrrrrrprlogilab.common.modutilsrlogilab.common.logging_extrlogilab.common.decoratorsrlogilab.common.deprecationrr-r.rrr7r*r9r*r,rurXrcrkrrr Exceptionrrrrrr~rrrrrdictrrr=rrrrr!r'r%rs$;|&  ''8877v 663: xC. " T#t)_!;x;D;AL"4ALH+EY+E\ > . )9 ))(IJ4K4EF-G-- -(&  *  'SXc]c&ae s) ( 8@tCQTH~W[G[A\8] 4S>4c3h0 012!#!#H4+46v sm"  CtS(3-T'Q!RRS|Wt|W~8C=E#JSWDSWn y)9:;)J/0 H  &!v&!r'