o gHd@sdZdZddlmZddlmZGdddejZGdddejeZ Gd d d ej e Z Gd d d e Z Gd ddeZ Gddde ZGddde eZdS)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@eZdZdZddZdS)IMinimalSequenceaMost 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). cCdS)z``x.__getitem__(index) <==> x[index]`` Declaring this interface does not specify whether `__getitem__` supports slice objects.Nindexrre/var/www/html/facialservice/flask-venv/lib/python3.10/site-packages/zope/interface/common/sequence.py __getitem__3zIMinimalSequence.__getitem__N)__name__ __module__ __qualname____doc__r rrrr r$s rc@eZdZdZdS)IFiniteSequencez[ A sequence of bound size. .. versionchanged:: 5.0.0 Extend ``ISized`` Nrrrrrrrr r9rc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS) 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`` cCr)z'``x.__contains__(item) <==> item in x``Nritemrrr __contains__Nr zIReadSequence.__contains__cCr)z"``x.__lt__(other) <==> x < other``Nrotherrrr __lt__Rr zIReadSequence.__lt__cCr)z#``x.__le__(other) <==> x <= other``Nrrrrr __le__Ur zIReadSequence.__le__cCr)z#``x.__eq__(other) <==> x == other``Nrrrrr __eq__Xr zIReadSequence.__eq__cCr)z#``x.__ne__(other) <==> x != other``Nrrrrr __ne__[r zIReadSequence.__ne__cCr)z"``x.__gt__(other) <==> x > other``Nrrrrr __gt__^r zIReadSequence.__gt__cCr)z#``x.__ge__(other) <==> x >= other``Nrrrrr __ge__ar zIReadSequence.__ge__cCr)z#``x.__add__(other) <==> x + other``Nrrrrr __add__dr zIReadSequence.__add__cCr)z``x.__mul__(n) <==> x * n``Nrnrrr __mul__gr zIReadSequence.__mul__cCr)z``x.__rmul__(n) <==> n * x``Nrr#rrr __rmul__jr zIReadSequence.__rmul__N)rrrrrrrrrr r!r"r%r&rrrr rAs  rc@s eZdZdZddZddZdS)IExtendedReadSequencezFull read interface for listscCr)z%Return number of occurrences of valueNrrrrr countqr zIExtendedReadSequence.countcGr)zTindex(value, [start, [stop]]) -> int Return first index of *value* Nr)rargsrrr r tr zIExtendedReadSequence.indexN)rrrrr(r rrrr r'ns r'c@sdeZdZdZddZddZddZdd Zd d Zdd dZ ddZ ddZ dddZ ddZ dS)IUniqueMemberWriteSequencezAThe write contract for a sequence that may enforce unique memberscCr)z``x.__setitem__(index, item) <==> x[index] = item`` Declaring this interface does not specify whether `__setitem__` supports slice objects. Nrr rrrr __setitem__}r z&IUniqueMemberWriteSequence.__setitem__cCr)z``x.__delitem__(index) <==> del x[index]`` Declaring this interface does not specify whether `__delitem__` supports slice objects. Nrr rrr __delitem__r z&IUniqueMemberWriteSequence.__delitem__cCr)z``x.__iadd__(y) <==> x += y``Nr)yrrr __iadd__r z#IUniqueMemberWriteSequence.__iadd__cCr)zAppend item to endNrrrrr appendr z!IUniqueMemberWriteSequence.appendcCr)zInsert item before indexNrr+rrr insertr z!IUniqueMemberWriteSequence.insertcCr)z.Remove and return item at index (default last)Nrr rrr popr zIUniqueMemberWriteSequence.popcCr)z Remove first occurrence of valueNrrrrr remover z!IUniqueMemberWriteSequence.removecCr)zReverse *IN PLACE*Nrrrrr reverser z"IUniqueMemberWriteSequence.reverseNcCr)z3Stable sort *IN PLACE*; `cmpfunc(x, y)` -> -1, 0, 1Nr)cmpfuncrrr sortr zIUniqueMemberWriteSequence.sortcCr)z3Extend list by appending elements from the iterableNr)iterablerrr extendr z!IUniqueMemberWriteSequence.extend)r2)N)rrrrr,r-r/r0r1r3r4r5r7r9rrrr r*zs   r*c@r)IWriteSequencez!Full write contract for sequencescCr)z``x.__imul__(n) <==> x *= n``Nrr#rrr __imul__r zIWriteSequence.__imul__N)rrrrr;rrrr r:s r:c@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 Nrrrrr r<rr<N)r __docformat__zope.interfacerzope.interface.commonr IIterablerISizedr IContainerrr'r*r:r<rrrr s   - )