+
    -½i›  ã                   ó  € R t Rt^ RIHt ^ RIHt  ! R R]P                  4      t ! R R]P                  ]4      t	 ! R R	]P                  ]	4      t ! R
 R]4      t ! R R]4      t ! R R]4      t ! R R]]4      tR# )a�  
Sequence Interfaces

Importing this module does *not* mark any standard classes as
implementing any of these interfaces.

While this module is not deprecated, new code should generally use
:mod:`zope.interface.common.collections`, specifically
:class:`~zope.interface.common.collections.ISequence` and
:class:`~zope.interface.common.collections.IMutableSequence`. This
module is occasionally useful for its fine-grained breakdown of interfaces.

The standard library :class:`list`, :class:`tuple` and
:class:`collections.UserList`, among others, implement ``ISequence``
or ``IMutableSequence`` but *do not* implement any of the interfaces
in this module.
Úrestructuredtext)Ú	Interface)Úcollectionsc                   ó*   a € ] tR t^%t o RtR tRtV tR# )ÚIMinimalSequencea·  Most basic sequence interface.

All sequences are iterable.  This requires at least one of the
following:

- a `__getitem__()` method that takes a single argument; integer
  values starting at 0 must be supported, and `IndexError` should
  be raised for the first index for which there is no value, or

- an `__iter__()` method that returns an iterator as defined in
  the Python documentation (http://docs.python.org/lib/typeiter.html).

c                ó   € R# )z``x.__getitem__(index) <==> x[index]``

Declaring this interface does not specify whether `__getitem__`
supports slice objects.N© ©Úindexs   &Ú@/usr/lib/python3/dist-packages/zope/interface/common/sequence.pyÚ__getitem__ÚIMinimalSequence.__getitem__4   ó   ‚ ó    r   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   Ú__static_attributes__Ú__classdictcell__©Ú__classdict__s   @r   r   r   %   s   ø‡ € ñ÷#ð #r   r   c                   ó   € ] tR t^;tRtRtR# )ÚIFiniteSequencezK
A sequence of bound size.

.. versionchanged:: 5.0.0
   Extend ``ISized``
r   N©r   r   r   r   r   r   r   r   r   r   r   ;   s   † õr   r   c                   ó`   a € ] tR t^Dt o RtR tR tR tR tR t	R t
R tR	 tR
 tR tRtV tR# )ÚIReadSequencea  
read interface shared by tuple and list

This interface is similar to
:class:`~zope.interface.common.collections.ISequence`, but
requires that all instances be totally ordered. Most users
should prefer ``ISequence``.

.. versionchanged:: 5.0.0
   Extend ``IContainer``
c                ó   € R# )z'``x.__contains__(item) <==> item in x``Nr   ©Úitems   &r   Ú__contains__ÚIReadSequence.__contains__Q   r   r   c                ó   € R# )z"``x.__lt__(other) <==> x < other``Nr   ©Úothers   &r   Ú__lt__ÚIReadSequence.__lt__U   r   r   c                ó   € R# )z#``x.__le__(other) <==> x <= other``Nr   r$   s   &r   Ú__le__ÚIReadSequence.__le__X   r   r   c                ó   € R# )z#``x.__eq__(other) <==> x == other``Nr   r$   s   &r   Ú__eq__ÚIReadSequence.__eq__[   r   r   c                ó   € R# )z#``x.__ne__(other) <==> x != other``Nr   r$   s   &r   Ú__ne__ÚIReadSequence.__ne__^   r   r   c                ó   € R# )z"``x.__gt__(other) <==> x > other``Nr   r$   s   &r   Ú__gt__ÚIReadSequence.__gt__a   r   r   c                ó   € R# )z#``x.__ge__(other) <==> x >= other``Nr   r$   s   &r   Ú__ge__ÚIReadSequence.__ge__d   r   r   c                ó   € R# )z#``x.__add__(other) <==> x + other``Nr   r$   s   &r   Ú__add__ÚIReadSequence.__add__g   r   r   c                ó   € R# )z``x.__mul__(n) <==> x * n``Nr   ©Úns   &r   Ú__mul__ÚIReadSequence.__mul__j   r   r   c                ó   € R# )z``x.__rmul__(n) <==> n * x``Nr   r;   s   &r   Ú__rmul__ÚIReadSequence.__rmul__m   r   r   r   N)r   r   r   r   r   r!   r&   r)   r,   r/   r2   r5   r8   r=   r@   r   r   r   s   @r   r   r   D   sA   ø‡ € ñ
ò6ò1ò2ò2ò2ò1ò2ò2ò*÷+ð +r   r   c                   ó0   a € ] tR t^qt o RtR tR tRtV tR# )ÚIExtendedReadSequencezFull read interface for listsc                ó   € R# )z%Return number of occurrences of valueNr   r   s   &r   ÚcountÚIExtendedReadSequence.countt   r   r   c                ó   € R# )zDindex(value, [start, [stop]]) -> int

Return first index of *value*
Nr   )r    Úargss   &*r   r
   ÚIExtendedReadSequence.indexw   r   r   r   N)	r   r   r   r   r   rE   r
   r   r   r   s   @r   rC   rC   q   s   ø‡ € Ù'ò4÷ð r   rC   c                   óh   a € ] tR t^~t o RtR tR tR tR tR t	RR lt
R tR	 tRR ltR tRtV tR
# )ÚIUniqueMemberWriteSequencezAThe write contract for a sequence that may enforce unique membersc                ó   € R# )z�``x.__setitem__(index, item) <==> x[index] = item``

Declaring this interface does not specify whether `__setitem__`
supports slice objects.
Nr   ©r
   r    s   &&r   Ú__setitem__Ú&IUniqueMemberWriteSequence.__setitem__�   r   r   c                ó   € R# )z„``x.__delitem__(index) <==> del x[index]``

Declaring this interface does not specify whether `__delitem__`
supports slice objects.
Nr   r	   s   &r   Ú__delitem__Ú&IUniqueMemberWriteSequence.__delitem__ˆ   r   r   c                ó   € R# )z``x.__iadd__(y) <==> x += y``Nr   )Úys   &r   Ú__iadd__Ú#IUniqueMemberWriteSequence.__iadd__�   r   r   c                ó   € R# )zAppend item to endNr   r   s   &r   ÚappendÚ!IUniqueMemberWriteSequence.append’   r   r   c                ó   € R# )zInsert item before indexNr   rM   s   &&r   ÚinsertÚ!IUniqueMemberWriteSequence.insert•   r   r   c                ó   € R# )z.Remove and return item at index (default last)Nr   r	   s   &r   ÚpopÚIUniqueMemberWriteSequence.pop˜   r   r   c                ó   € R# )z Remove first occurrence of valueNr   r   s   &r   ÚremoveÚ!IUniqueMemberWriteSequence.remove›   r   r   c                 ó   € R# )zReverse *IN PLACE*Nr   r   r   r   ÚreverseÚ"IUniqueMemberWriteSequence.reversež   r   r   Nc                ó   € R# )z3Stable sort *IN PLACE*; `cmpfunc(x, y)` -> -1, 0, 1Nr   )Úcmpfuncs   &r   ÚsortÚIUniqueMemberWriteSequence.sort¡   r   r   c                ó   € R# )z3Extend list by appending elements from the iterableNr   )Úiterables   &r   ÚextendÚ!IUniqueMemberWriteSequence.extend¤   r   r   r   )éÿÿÿÿ)N)r   r   r   r   r   rN   rQ   rU   rX   r[   r^   ra   rd   rh   rl   r   r   r   s   @r   rK   rK   ~   sB   ø‡ € ÙKòòò,ò!ò'ô=ò/ò!ôB÷Bð Br   rK   c                   ó*   a € ] tR t^¨t o RtR tRtV tR# )ÚIWriteSequencez!Full write contract for sequencesc                ó   € R# )z``x.__imul__(n) <==> x *= n``Nr   r;   s   &r   Ú__imul__ÚIWriteSequence.__imul__«   r   r   r   N)r   r   r   r   r   rr   r   r   r   s   @r   rp   rp   ¨   s   ø‡ € Ù+÷,ð ,r   rp   c                   ó   € ] tR t^¯tRtRtR# )Ú	ISequencea‚  
Full sequence contract.

New code should prefer
:class:`~zope.interface.common.collections.IMutableSequence`.

Compared to that interface, which is implemented by :class:`list`
(:class:`~zope.interface.common.builtins.IList`), among others,
this interface is missing the following methods:

    - clear

    - count

    - index

This interface adds the following methods:

    - sort
r   Nr   r   r   r   ru   ru   ¯   s   † õr   ru   N)r   Ú__docformat__Úzope.interfacer   Úzope.interface.commonr   Ú	IIterabler   ÚISizedr   Ú
IContainerr   rC   rK   rp   ru   r   r   r   Ú<module>r|      s‰   ðñð$ #€Ý $Ý -ô#�{×,Ñ,ô #ô,�k×(Ñ(Ð*:ô ô*+�K×*Ñ*¨Oô *+ôZ
˜Mô 
ô'B ô 'BôT,Ð/ô ,ô�˜~ö r   