File: //proc/3/root/lib64/python2.7/abc.pyo
�
zfc           @   s}   d  Z  d d l Z d d l m Z d d d �  �  YZ e e �  � Z d �  Z d e f d �  �  YZ	 d	 e f d
 �  �  YZ
 d S(   s3   Abstract Base Classes (ABCs) according to PEP 3119.i����N(   t   WeakSett   _Cc           B   s   e  Z RS(    (   t   __name__t
   __module__(    (    (    s   /usr/lib64/python2.7/abc.pyR      s    c         C   s
   t  |  _ |  S(   s�  A decorator indicating abstract methods.
    Requires that the metaclass is ABCMeta or derived from it.  A
    class that has a metaclass derived from ABCMeta cannot be
    instantiated unless all of its abstract methods are overridden.
    The abstract methods can be called using any of the normal
    'super' call mechanisms.
    Usage:
        class C:
            __metaclass__ = ABCMeta
            @abstractmethod
            def my_abstract_method(self, ...):
                ...
    (   t   Truet   __isabstractmethod__(   t   funcobj(    (    s   /usr/lib64/python2.7/abc.pyt   abstractmethod   s    	t   abstractpropertyc           B   s   e  Z d  Z e Z RS(   s/  A decorator indicating abstract properties.
    Requires that the metaclass is ABCMeta or derived from it.  A
    class that has a metaclass derived from ABCMeta cannot be
    instantiated unless all of its abstract properties are overridden.
    The abstract properties can be called using any of the normal
    'super' call mechanisms.
    Usage:
        class C:
            __metaclass__ = ABCMeta
            @abstractproperty
            def my_abstract_property(self):
                ...
    This defines a read-only property; you can also define a read-write
    abstract property using the 'long' form of property declaration:
        class C:
            __metaclass__ = ABCMeta
            def getx(self): ...
            def setx(self, value): ...
            x = abstractproperty(getx, setx)
    (   R   R   t   __doc__R   R   (    (    (    s   /usr/lib64/python2.7/abc.pyR   $   s   t   ABCMetac           B   sD   e  Z d  Z d Z d �  Z d �  Z d d � Z d �  Z d �  Z	 RS(   si  Metaclass for defining Abstract Base Classes (ABCs).
    Use this metaclass to create an ABC.  An ABC can be subclassed
    directly, and then acts as a mix-in class.  You can also register
    unrelated concrete classes (even built-in classes) and unrelated
    ABCs as 'virtual subclasses' -- these and their descendants will
    be considered subclasses of the registering ABC by the built-in
    issubclass() function, but the registering ABC won't show up in
    their MRO (Method Resolution Order) nor will method
    implementations defined by the registering ABC be callable (not
    even via super()).
    i    c         C   s�   t  t |  � j |  | | | � } t d �  | j �  D� � } xb | D]Z } xQ t | d t �  � D]: } t | | d  � } t | d t � r` | j | � q` q` WqD Wt	 | � | _
 t �  | _ t �  | _
 t �  | _ t j | _ | S(   Nc         s   s-   |  ]# \ } } t  | d  t � r | Vq d S(   R   N(   t   getattrt   False(   t   .0t   namet   value(    (    s   /usr/lib64/python2.7/abc.pys	   <genexpr>Y   s   	t   __abstractmethods__R   (   t   superR
   t   __new__t   sett   itemsR   t   NoneR   t   addt	   frozensetR   R    t
   _abc_registryt
   _abc_cachet   _abc_negative_cachet   _abc_invalidation_countert   _abc_negative_cache_version(   t   mclsR   t   basest	   namespacet   clst	   abstractst   baseR   (    (    s   /usr/lib64/python2.7/abc.pyR   V   s    !	
c         C   s{   t  | t t j f � s'