Ñò
ÐwHc @ sÕ d Z d d k l Z l Z l Z d d k l Z d d k l Z l Z l
Z
l Z l Z l
Z
l Z l Z l Z l Z l Z d d k l Z l Z d d d d d
g Z d „ Z d e f d
„ ƒ YZ d e e f d „ ƒ YZ d e f d „ ƒ YZ d e
e f d „ ƒ YZ d e e f d „ ƒ YZ e
e e ƒ e
e e ƒ e
e e ƒ e
e e ƒ e
e e ƒ e
e e ƒ d d d „ Z e e d d ƒ Z e e d d ƒ Z! e e d ƒ Z" e e d ƒ Z# d „ Z$ d S( sò
This module provides four decorators:
``prioritized_when``
``prioritized_around``
``prioritized_before``
``prioritized_after``
These behave like their ``peak.rules`` counterparts except that they accept an
optional ``prio`` argument which can be used to provide a comparable object
(usually an integer) that will be used to disambiguate
situations in which more than rule applies to the given arguments and no rule
is more specific than another. That is, situations in which an
``peak.rules.AmbiguousMethods`` would have been raised.
This is useful for libraries which want to be extensible via generic functions
but want their users to easily override a method without figuring out how to
write a more specific rule or when it is not feasible.
For example, TurboJson provides a ``jsonify`` function that looks like this::
>>> def jsonify(obj):
... "jsonify an object"
And extends it so it can handle SqlAlchemy mapped classes in a way
similar to this one::
>>> from peak.rules import when
>>> def jsonify_sa(obj):
... print "You're a SA object and I'm going to jsonify you!"
>>> when(jsonify, "hasattr(obj, 'c')")(jsonify_sa) # doctest: +ELLIPSIS
>>> class Person(object):
... def __init__(self):
... self.c = "im a stub"
>>> jsonify(Person())
You're a SA object and I'm going to jsonify you!
So far so good, however, when a user of the library wants to override the built
in implementation it can become quite hard since they have to write a more
specific rule which can be tedious, for example::
hasattr(self, 'c') and isinstance(obj, Person)
Notice the ``hasattr`` test, even though ``isinstance(obj, Person)`` implies it,
just to make it more specific than the built in, this gets more cumbersome the
more complicated the expression becomes.
Else this is what happens::
>>> def jsonify_Person(obj):
... print "No way, I'm going to jsonify you!"
>>> when(jsonify, (Person,))(jsonify_Person) # doctest: +ELLIPSIS
>>> try:
... jsonify(Person())
... except AmbiguousMethods:
... print "I told you, gfs can sometimes be a pain"
I told you, gfs can sometimes be a pain
To remedy this situation ``prioritized_when`` can be used to provide an
implementation that will override the one declared with ``when``::
>>> def jsonify_Person2(obj):
... print "No way, I'm going to jsonify you!"
>>> prioritized_when(jsonify, (Person,))(jsonify_Person2) # doctest: +ELLIPSIS
>>> jsonify(Person())
No way, I'm going to jsonify you!
Notice that we didn't need a ``prio`` argument. This is because methods
decorated with ``prioritized_when`` always override those that have been
decorated with ``peak.rules.when``.
Methods decorated with ``prioritized_when`` can also override other methods
that have been decorated by the same decorator using the ``prio`` parameter,
the one which compares greater wins, if both are equal
``AmbiguousMethods`` will be raised as usual.
>>> def jsonify_Person3(obj):
... print "Don't be so smart, I am, my prio is higher!"
>>> prioritized_when(jsonify, (Person,), prio=1)(jsonify_Person3) # doctest: +ELLIPSIS
>>> jsonify(Person())
Don't be so smart, I am, my prio is higher!
For convenience, a ``generic`` decorator is provided too which behaves
like ``peak.rules.dispatch.generic`` except that the ``when``,...,``after``
decorators that will be bound as attributes of the decorated function will be
prioritized::
>>> @generic
... def f(n): pass
>>> f(5)
Traceback (most recent call last):
...
NoApplicableMethods: ((5,), {})
Add a default rule::
>>> @f.when()
... def default_f(n):
... return n
>>> f(5)
5
Add a default rule that overrides the former::
>>> @f.when(prio=1)
... def new_default_f(n):
... return n+1
>>> f(5)
6
iÿÿÿÿ( t decorate_assignmentt frameinfot decorate_class( t with_name( t Methodt Aroundt Beforet Aftert abstractt always_overridest AmbiguousMethodst Dispatchingt rules_fort
parse_rulet combine_actions( t clone_functiont ParseContextt prioritized_whent prioritized_aroundt prioritized_aftert prioritized_beforeR c C s( t | t ƒ o d St | i d d ƒ S( Niayþÿt prioi ( t
isinstanceR
t getattrt body( t obj( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt _get_prio‘ s t PrioritizedMixinc B s e Z d „ Z RS( c C s” t | ƒ } t | ƒ } | | j o) | i o | i t | i | ƒ ƒ S| S| | j o) | i o | i t | i | ƒ ƒ S| St | | g ƒ S( s×
Merge with other Methods giving priority to the one with the highest
``prio`` attribute in the Method's body.
If both priorities are equal return :exc:`peak.rules.AmbiguousMethods`
( R t can_tailt tail_withR t tailR
( t selft othert my_priot
other_prio( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt merge™ s
( t __name__t
__module__R# ( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyR ˜ s t PrioritizedMethodc B s e Z d Z RS( sº
A :class:`peak.rules.Method` subclass that will merge ambiguous
methods giving preference to the one that has the ``prio`` attribute
in it's body that compares greater.
( R$ R% t __doc__( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyR& ¬ s t PrioritizedAroundc B s e Z d Z RS( sq
A :class:`PrioritizedMethod` subclass that has preference
over any other :class:`peak.rules.Method`
( R$ R% R' ( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyR( ³ s t PrioritizedBeforec B s e Z d Z RS( s3 Method(s) to be called before the primary method(s)( R$ R% R' ( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyR) ¹ s t PrioritizedAfterc B s e Z d Z RS( s2 Method(s) to be called after the primary method(s)( R$ R% R' ( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyR* ½ s i c su | d j o d | i } n | t j o
d ‰ n
| i ‰ d d d | ‡ f d † } t | | ƒ } | | _ | S( Ns6 Extend a generic function with a method of type ``%s``i c s+ ‡ ‡ ‡ ‡ ‡ f d † } t | | ˆ ƒ S( Nc sØ | } t | ƒ } ˆ | _ ˆ p | } t ˆ ƒ ‰ t ˆ ƒ i ‰ t | ƒ \ } } } } t | ˆ | | ƒ ‰ ‡ ‡ ‡ ‡ f d † }
| d j o t |
d | ƒn |
d ƒ | i | ƒ ˆ ˆ f j o ˆ S| S( Nc s ˆ i t ˆ ˆ ˆ | ƒ ƒ | S( N( t addR
( t cls( t enginet rulest predt context( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt register_for_classã s t classt frame(
R R R R R- R R R t Nonet get( t cb_framet namet funct
old_localst orig_funct
real_framet kindt modulet locals_t globals_R1 ( R R3 R/ t ft maker( R- R. R0 s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt callbackØ s
( R ( R@ R/ t depthR3 R RB ( RA ( R R@ R/ R3 s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt decorate× s ( ( R4 R$ R t makeR R' ( R, R7 t doct default_prioRD ( ( RA s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt make_decoratorÏ s
sô
Extend a generic function with a new action. Optional parameter ``prio``
can be used to prioritize the new action in case adding it causes an
:exc:`peak.rules.AmbiguousMethod` exception when the generic function
is called.
s?
Extend a generic function with a new action. This action will be executed
before any action registered with ``prioritized_when``.
Optional parameter ``prio`` can be used to prioritize the new action in
case adding it causes an ``AmbiguousMethod`` exception when the generic
function is called.
c C sR t i | ƒ | _ t i | ƒ | _ t i | ƒ | _ t i | ƒ | _ t | ƒ S( s¦
Convenience decorator to bind ``when``, ``around``, ``after`` and
``before`` decorators to the decorated function and declareing it as
``abstract``.
(
R t __get__t whenR t aroundR t beforeR t afterR ( R8 ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt generic s
N(% R' t peak.util.decoratorsR R R t peak.util.assemblerR t
peak.rulesR R R R R R R
R R R
R t peak.rules.coreR R t __all__R t objectR R& R( R) R* R4 RH R R R R RN ( ( ( s7 /usr/lib/python2.6/site-packages/prioritized_methods.pyt ƒ s< L
+