Home-AssistantConfig/deps/sqlalchemy/sql/__pycache__/operators.cpython-34.pyc

<EFBFBD>
|<7C><>W<EFBFBD>Y<00>	@s<>dZd
dl
mZ
ddlmZmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZmZmZmZ
ejr<>ddlmZ
neZGdd<00>de<00>ZGdd	<00>d	e<00>ZGd
d<00>de<00>Zdd
<00>Zdd<00>Zdd<00>Zdd<00>Z dd<00>Z!dd<00>Z"dd<00>Z#dd<00>Z$dd<00>Z%ddd <00>
Z&dd!d"<00>
Z'dd#d$<00>
Z(dd%d&<00>
Z)d'd(d)<00>
Z*d'd*d+<00>
Z+d,d-<00>Z,d.d/<00>Z-d0d1<00>Z.dd2d3<00>
Z/dd4d5<00>
Z0dd6d7<00>
Z1dd8d9<00>
Z2dd:d;<00>
Z3dd<d=<00>
Z4d>d?<00>Z5d@dA<00>Z6dBdC<00>Z7dDdE<00>Z8dFdG<00>Z9dHdI<00>Z:dJdK<00>Z;dLdM<00>Z<e=eeeeg<00>
Z>e=eeeeee
e*e&g<00>
Z?dNdO<00>Z@dPdQ<00>ZAdRdS<00>ZBe>jCe8eeg<00>
ZDeDjCeg
<00>
ZEejFdTdUdV<0B>

ZGejFdWdUdX<0B>

ZHejFdYdUdX<00>

ZIi+dZe6dZe6d[e6d[e6d[e6d[e
6d[e6d\e6d\e	6d]e86d]e56d]e66d]e(6d]e)6d]e&6d]e'6d]e,6d]e-6d]e"6d]e#6d^e6d^e6d^e6d^e6d^e6d^e
6d^e*6d^e+6d^e.6d^e6d^e 6d^e!6d_e6d
e6d`e76d_e96d_e:6dae$6d`e6de6dVeG6eHeH6eIeI6ZJdbdc<00>ZKdS)dz*Defines operators used in SQL expressions.<2E>)
<01>util<69>)<13>and_<64>or_<72>inv<6E>add<64>mul<75>sub<75>mod<6F>truediv<69>lt<6C>le<6C>ne<6E>gt<67>ge<67>eq<65>neg<65>getitem<65>lshift<66>rshift<66>contains)
<01>divc@sjeZ
dZd
ZfZdd<00>Zdd<00>Zdd<00>Zdd	d
d<00>Zdd
<00>Z	dd<00>Z
dS)<11>	Operatorsa<73>
Base of comparison and logical operators.

    Implements base methods
    :meth:`~sqlalchemy.sql.operators.Operators.operate` and
    :meth:`~sqlalchemy.sql.operators.Operators.reverse_operate`, as well as
    :meth:`~sqlalchemy.sql.operators.Operators.__and__`,
    :meth:`~sqlalchemy.sql.operators.Operators.__or__`,
    :meth:`~sqlalchemy.sql.operators.Operators.__invert__`.

    Usually is used via its most common subclass
    :class:`.ColumnOperators`.

    cCs|jt
|
<00>S)
a.Implement the ``&`` operator.

        When used with SQL expressions, results in an
        AND operation, equivalent to
        :func:`~.expression.and_`, that is::

            a & b

        is equivalent to::

            from sqlalchemy import and_
            and_(a, b)

        Care should be taken when using ``&`` regarding
        operator precedence; the ``&`` operator has the highest precedence.
        The operands should be enclosed in parenthesis if they contain
        further sub expressions::

            (a == 2) & (b == 4)

        )<02>operater)<02>self<6C>other<65>r<00>>/tmp/pip-build-zkr322cu/sqlalchemy/sqlalchemy/sql/operators.py<70>__and__+szOperators.__and__cCs|jt
|
<00>S)
a*Implement the ``|`` operator.

        When used with SQL expressions, results in an
        OR operation, equivalent to
        :func:`~.expression.or_`, that is::

            a | b

        is equivalent to::

            from sqlalchemy import or_
            or_(a, b)

        Care should be taken when using ``|`` regarding
        operator precedence; the ``|`` operator has the highest precedence.
        The operands should be enclosed in parenthesis if they contain
        further sub expressions::

            (a == 2) | (b == 4)

        )rr)rrrrr<00>__or__CszOperators.__or__c

Cs
|jt
<00>
S)
a
Implement the ``~`` operator.

        When used with SQL expressions, results in a
        NOT operation, equivalent to
        :func:`~.expression.not_`, that is::

            ~a

        is equivalent to::

            from sqlalchemy import not_
            not_(a)

        )rr)
rrrr<00>
__invert__[szOperators.__invert__rFcs+t|
||<00><00><00><00>
fd
d<00>}|S)ahproduce a generic operator function.

        e.g.::

          somecolumn.op("*")(5)

        produces::

          somecolumn * 5

        This function can also be used to make bitwise operators explicit. For
        example::

          somecolumn.op('&')(0xff)

        is a bitwise AND of the value in ``somecolumn``.

        :param operator: a string which will be output as the infix operator
          between this element and the expression passed to the
          generated function.

        :param precedence: precedence to apply to the operator, when
         parenthesizing expressions.  A lower number will cause the expression
         to be parenthesized when applied against another operator with
         higher precedence.  The default value of ``0`` is lower than all
         operators except for the comma (``,``) and ``AS`` operators.
         A value of 100 will be higher or equal to all operators, and -100
         will be lower than or equal to all operators.

         .. versionadded:: 0.8 - added the 'precedence' argument.

        :param is_comparison: if True, the operator will be considered as a
         "comparison" operator, that is which evaluates to a boolean
         true/false value, like ``==``, ``>``, etc.  This flag should be set
         so that ORM relationships can establish that the operator is a
         comparison operator when used in a custom join condition.

         .. versionadded:: 0.9.2 - added the
            :paramref:`.Operators.op.is_comparison` flag.

        .. seealso::

            :ref:`types_operators`

            :ref:`relationship_custom_operator`

        c

s
<00><00>
|<00>S)
Nr)
r)<02>operatorrrr<00>against<73>s
zOperators.op.<locals>.against)
<01>	custom_op)r<00>opstring<6E>
precedence<EFBFBD>
is_comparisonr"r)r!rr<00>opls0zOperators.opcOstt
|
<00>
<00>
<00>
d
S)a3Operate on an argument.

        This is the lowest level of operation, raises
        :class:`NotImplementedError` by default.

        Overriding this on a subclass can allow common
        behavior to be applied to all operations.
        For example, overriding :class:`.ColumnOperators`
        to apply ``func.lower()`` to the left and right
        side::

            class MyComparator(ColumnOperators):
                def operate(self, op, other):
                    return op(func.lower(self), func.lower(other))

        :param op:  Operator callable.
        :param \*other: the 'other' side of the operation. Will
         be a single scalar for most operations.
        :param \**kwargs: modifiers.  These may be passed by special
         operators such as :meth:`ColumnOperators.contains`.


        N)<02>NotImplementedError<6F>str)rr'r<00>kwargsrrrr<00>szOperators.operatecKstt
|
<00>
<00>
<00>
d
S)zXReverse operate on an argument.

        Usage is the same as :meth:`operate`.

        N)r(r))rr'rr*rrr<00>reverse_operate<74>szOperators.reverse_operateN)<0B>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__<5F>	__slots__rrr r'rr+rrrrrs

6rc@sReZ
dZd
ZdZdddd<00>Zdd<00>Zdd	<00>Zd
d<00>ZdS)
r#aURepresent a 'custom' operator.

    :class:`.custom_op` is normally instantitated when the
    :meth:`.ColumnOperators.op` method is used to create a
    custom operator callable.  The class can also be used directly
    when programmatically constructing expressions.   E.g.
    to represent the "factorial" operation::

        from sqlalchemy.sql import UnaryExpression
        from sqlalchemy.sql import operators
        from sqlalchemy import Numeric

        unary = UnaryExpression(table.c.somecolumn,
                modifier=operators.custom_op("!"),
                type_=Numeric)

    rFcCs|
|_||_
||_dS)
N)r$r%r&)rr$r%r&rrr<00>__init__<5F>s
	
	
zcustom_op.__init__cCst|
t
<00>o|
j|jkS)
N)<03>
isinstancer#r$)rrrrr<00>__eq__<5F>s

zcustom_op.__eq__c

Cs
t|<00>
S)
N)
<01>id)
rrrr<00>__hash__<5F>s
zcustom_op.__hash__cKs|
j|||<00>S)
N)
r)r<00>left<66>right<68>kwrrr<00>__call__<5F>s
zcustom_op.__call__N)r,r-r.r/r1r3r5r9rrrrr#<00>s
r#c@s>eZ
dZd
ZfZdZdd<00>Zdd<00>Zej	Z	dd<00>Z
d	d
<00>Zdd<00>Zd
d<00>Z
dd<00>Zdd<00>Zdd<00>Zdd<00>Zdd<00>Zdd<00>Zddd<00>
Zddd<00>
Zdd <00>Zd!d"<00>Zdd#d$<00>
Zdd%d&<00>
Zd'd(<00>Zd)d*<00>Zd+d,<00>Zd-d.<00>Zd/d0<00>Zd1d2<00>Zd3d4<00>Z d5d6<00>Z!d7d8<00>Z"d9d:<00>Z#d;d<<00>Z$d=d><00>Z%d?d@<00>Z&dAdB<00>Z'dCdD<00>Z(dEdF<00>Z)dGdHdI<00>
Z*dJdK<00>Z+dLdM<00>Z,dNdO<00>Z-dPdQ<00>Z.dRdS<00>Z/dTdU<00>Z0dVdW<00>Z1dXdY<00>Z2dS)Z<>ColumnOperatorsa<73>Defines boolean, comparison, and other operators for
    :class:`.ColumnElement` expressions.

    By default, all methods call down to
    :meth:`.operate` or :meth:`.reverse_operate`,
    passing in the appropriate operator function from the
    Python builtin ``operator`` module or
    a SQLAlchemy-specific operator function from
    :mod:`sqlalchemy.expression.operators`.   For example
    the ``__eq__`` function::

        def __eq__(self, other):
            return self.operate(operators.eq, other)

    Where ``operators.eq`` is essentially::

        def eq(a, b):
            return a == b

    The core column expression unit :class:`.ColumnElement`
    overrides :meth:`.Operators.operate` and others
    to return further :class:`.ColumnElement` constructs,
    so that the ``==`` operation above is replaced by a clause
    construct.

    See also:

    :ref:`types_operators`

    :attr:`.TypeEngine.comparator_factory`

    :class:`.ColumnOperators`

    :class:`.PropComparator`

    NcCs|jt
|
<00>S)
zdImplement the ``<`` operator.

        In a column context, produces the clause ``a < b``.

        )rr)rrrrr<00>__lt__
szColumnOperators.__lt__cCs|jt
|
<00>S)
zfImplement the ``<=`` operator.

        In a column context, produces the clause ``a <= b``.

        )rr
)rrrrr<00>__le__
szColumnOperators.__le__cCs|jt
|
<00>S)
z<>Implement the ``==`` operator.

        In a column context, produces the clause ``a = b``.
        If the target is ``None``, produces ``a IS NULL``.

        )rr)rrrrrr3&
szColumnOperators.__eq__cCs|jt
|
<00>S)
z<>Implement the ``!=`` operator.

        In a column context, produces the clause ``a != b``.
        If the target is ``None``, produces ``a IS NOT NULL``.

        )rr)rrrrr<00>__ne__/
szColumnOperators.__ne__cCs|jt
|
<00>S)
zdImplement the ``>`` operator.

        In a column context, produces the clause ``a > b``.

        )rr)rrrrr<00>__gt__8
szColumnOperators.__gt__cCs|jt
|
<00>S)
zfImplement the ``>=`` operator.

        In a column context, produces the clause ``a >= b``.

        )rr)rrrrr<00>__ge__@
szColumnOperators.__ge__c

Cs
|jt
<00>
S)
zaImplement the ``-`` operator.

        In a column context, produces the clause ``-a``.

        )rr)
rrrr<00>__neg__H
szColumnOperators.__neg__cCs|jt
|
<00>S)
N)rr)rrrrr<00>__contains__P
s
zColumnOperators.__contains__cCs|jt
|
<00>S)
z<>Implement the [] operator.

        This can be used by some database-specific types
        such as Postgresql ARRAY and HSTORE.

        )rr)r<00>indexrrr<00>__getitem__S
szColumnOperators.__getitem__cCs|jt
|
<00>S)
z<>implement the << operator.

        Not used by SQLAlchemy core, this is provided
        for custom operator systems which want to use
        << as an extension point.
        )rr)rrrrr<00>
__lshift__\
szColumnOperators.__lshift__cCs|jt
|
<00>S)
z<>implement the >> operator.

        Not used by SQLAlchemy core, this is provided
        for custom operator systems which want to use
        >> as an extension point.
        )rr)rrrrr<00>
__rshift__e
szColumnOperators.__rshift__cCs|jt
|
<00>S)
z<>Implement the 'concat' operator.

        In a column context, produces the clause ``a || b``,
        or uses the ``concat()`` operator on MySQL.

        )r<00>	concat_op)rrrrr<00>concatn
szColumnOperators.concatcCs|jt
|
d
|<00>
S)a<>
Implement the ``like`` operator.

        In a column context, produces the clause ``a LIKE other``.

        E.g.::

            select([sometable]).where(sometable.c.column.like("%foobar%"))

        :param other: expression to be compared
        :param escape: optional escape character, renders the ``ESCAPE``
          keyword, e.g.::

            somecolumn.like("foo/%bar", escape="/")

        .. seealso::

            :meth:`.ColumnOperators.ilike`

        <20>escape)r<00>like_op)rrrHrrr<00>likew
szColumnOperators.likecCs|jt
|
d
|<00>
S)a<>
Implement the ``ilike`` operator.

        In a column context, produces the clause ``a ILIKE other``.

        E.g.::

            select([sometable]).where(sometable.c.column.ilike("%foobar%"))

        :param other: expression to be compared
        :param escape: optional escape character, renders the ``ESCAPE``
          keyword, e.g.::

            somecolumn.ilike("foo/%bar", escape="/")

        .. seealso::

            :meth:`.ColumnOperators.like`

        rH)r<00>ilike_op)rrrHrrr<00>ilike<6B>
szColumnOperators.ilikecCs|jt
|
<00>S)
z<>Implement the ``in`` operator.

        In a column context, produces the clause ``a IN other``.
        "other" may be a tuple/list of column expressions,
        or a :func:`~.expression.select` construct.

        )r<00>in_op)rrrrr<00>in_<6E>
szColumnOperators.in_cCs|jt
|
<00>S)
z<>implement the ``NOT IN`` operator.

        This is equivalent to using negation with
        :meth:`.ColumnOperators.in_`, i.e. ``~x.in_(y)``.

        .. versionadded:: 0.8

        .. seealso::

            :meth:`.ColumnOperators.in_`

        )r<00>notin_op)rrrrr<00>notin_<6E>
s
zColumnOperators.notin_cCs|jt
|
d
|<00>
S)z<>implement the ``NOT LIKE`` operator.

        This is equivalent to using negation with
        :meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``.

        .. versionadded:: 0.8

        .. seealso::

            :meth:`.ColumnOperators.like`

        rH)r<00>
notlike_op)rrrHrrr<00>notlike<6B>
s
zColumnOperators.notlikecCs|jt
|
d
|<00>
S)a

implement the ``NOT ILIKE`` operator.

        This is equivalent to using negation with
        :meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``.

        .. versionadded:: 0.8

        .. seealso::

            :meth:`.ColumnOperators.ilike`

        rH)r<00>notilike_op)rrrHrrr<00>notilike<6B>
s
zColumnOperators.notilikecCs|jt
|
<00>S)
aw
Implement the ``IS`` operator.

        Normally, ``IS`` is generated automatically when comparing to a
        value of ``None``, which resolves to ``NULL``.  However, explicit
        usage of ``IS`` may be desirable if comparing to boolean values
        on certain platforms.

        .. versionadded:: 0.7.9

        .. seealso:: :meth:`.ColumnOperators.isnot`

        )r<00>is_)rrrrrrU<00>
s
zColumnOperators.is_cCs|jt
|
<00>S)
a<>
Implement the ``IS NOT`` operator.

        Normally, ``IS NOT`` is generated automatically when comparing to a
        value of ``None``, which resolves to ``NULL``.  However, explicit
        usage of ``IS NOT`` may be desirable if comparing to boolean values
        on certain platforms.

        .. versionadded:: 0.7.9

        .. seealso:: :meth:`.ColumnOperators.is_`

        )r<00>isnot)rrrrrrV<00>
s
zColumnOperators.isnotcKs|jt
|
|<00>S)
zuImplement the ``startwith`` operator.

        In a column context, produces the clause ``LIKE '<other>%'``

        )r<00>
startswith_op)rrr*rrr<00>
startswith<EFBFBD>
szColumnOperators.startswithcKs|jt
|
|<00>S)
zrImplement the 'endswith' operator.

        In a column context, produces the clause ``LIKE '%<other>'``

        )r<00>endswith_op)rrr*rrr<00>endswithszColumnOperators.endswithcKs|jt
|
|<00>S)
zsImplement the 'contains' operator.

        In a column context, produces the clause ``LIKE '%<other>%'``

        )r<00>contains_op)rrr*rrrrszColumnOperators.containscKs|jt
|
|<00>S)
aYImplements a database-specific 'match' operator.

        :meth:`~.ColumnOperators.match` attempts to resolve to
        a MATCH-like function or operator provided by the backend.
        Examples include:

        * Postgresql - renders ``x @@ to_tsquery(y)``
        * MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)``
        * Oracle - renders ``CONTAINS(x, y)``
        * other backends may provide special implementations.
        * Backends without any special implementation will emit
          the operator as "MATCH".  This is compatible with SQlite, for
          example.

        )r<00>match_op)rrr*rrr<00>matchszColumnOperators.matchc

Cs
|jt
<00>
S)
zMProduce a :func:`~.expression.desc` clause against the
        parent object.)r<00>desc_op)
rrrr<00>desc"szColumnOperators.descc

Cs
|jt
<00>
S)
zLProduce a :func:`~.expression.asc` clause against the
        parent object.)r<00>asc_op)
rrrr<00>asc'szColumnOperators.ascc

Cs
|jt
<00>
S)
zSProduce a :func:`~.expression.nullsfirst` clause against the
        parent object.)r<00>
nullsfirst_op)
rrrr<00>
nullsfirst,szColumnOperators.nullsfirstc

Cs
|jt
<00>
S)
zRProduce a :func:`~.expression.nullslast` clause against the
        parent object.)r<00>nullslast_op)
rrrr<00>	nullslast1szColumnOperators.nullslastcCs|jt
|
<00>S)
zlProduce a :func:`~.expression.collate` clause against
        the parent object, given the collation string.)r<00>collate)rZ	collationrrrrf6szColumnOperators.collatecCs|jt
|
<00>S)
zaImplement the ``+`` operator in reverse.

        See :meth:`.ColumnOperators.__add__`.

        )r+r)rrrrr<00>__radd__;szColumnOperators.__radd__cCs|jt
|
<00>S)
zaImplement the ``-`` operator in reverse.

        See :meth:`.ColumnOperators.__sub__`.

        )r+r	)rrrrr<00>__rsub__CszColumnOperators.__rsub__cCs|jt
|
<00>S)
zaImplement the ``*`` operator in reverse.

        See :meth:`.ColumnOperators.__mul__`.

        )r+r)rrrrr<00>__rmul__KszColumnOperators.__rmul__cCs|jt
|
<00>S)
zaImplement the ``/`` operator in reverse.

        See :meth:`.ColumnOperators.__div__`.

        )r+r)rrrrr<00>__rdiv__SszColumnOperators.__rdiv__cCs|jt
|
<00>S)
zaImplement the ``%`` operator in reverse.

        See :meth:`.ColumnOperators.__mod__`.

        )r+r
)rrrrr<00>__rmod__[szColumnOperators.__rmod__FcCs|jt
|
|d
|<00>
S)z{Produce a :func:`~.expression.between` clause against
        the parent object, given the lower and upper range.

        <20>	symmetric)r<00>
between_op)rZcleftZcrightrlrrr<00>betweencszColumnOperators.betweenc

Cs
|jt
<00>
S)
z[Produce a :func:`~.expression.distinct` clause against the
        parent object.

        )r<00>distinct_op)
rrrr<00>distinctjszColumnOperators.distinctcCs|jt
|
<00>S)
a4
Implement the ``+`` operator.

        In a column context, produces the clause ``a + b``
        if the parent object has non-string affinity.
        If the parent object has a string affinity,
        produces the concatenation operator, ``a || b`` -
        see :meth:`.ColumnOperators.concat`.

        )rr)rrrrr<00>__add__qs
zColumnOperators.__add__cCs|jt
|
<00>S)
zdImplement the ``-`` operator.

        In a column context, produces the clause ``a - b``.

        )rr	)rrrrr<00>__sub__}szColumnOperators.__sub__cCs|jt
|
<00>S)
zdImplement the ``*`` operator.

        In a column context, produces the clause ``a * b``.

        )rr)rrrrr<00>__mul__<5F>szColumnOperators.__mul__cCs|jt
|
<00>S)
zdImplement the ``/`` operator.

        In a column context, produces the clause ``a / b``.

        )rr)rrrrr<00>__div__<5F>szColumnOperators.__div__cCs|jt
|
<00>S)
zdImplement the ``%`` operator.

        In a column context, produces the clause ``a % b``.

        )rr
)rrrrr<00>__mod__<5F>szColumnOperators.__mod__cCs|jt
|
<00>S)
zeImplement the ``//`` operator.

        In a column context, produces the clause ``a / b``.

        )rr)rrrrr<00>__truediv__<5F>szColumnOperators.__truediv__cCs|jt
|
<00>S)
zfImplement the ``//`` operator in reverse.

        See :meth:`.ColumnOperators.__truediv__`.

        )r+r)rrrrr<00>__rtruediv__<5F>szColumnOperators.__rtruediv__)3r,r-r.r/r0<00>	timetupler;r<rr5r3r=r>r?r@rArCrDrErGrJrLrNrPrRrTrUrVrXrZrr]r_rarcrerfrgrhrirjrkrnrprqrrrsrtrurvrwrrrrr:<00>s^$							
r:c
Cs
t<00><00>
dS)
N)
r(rrrr<00>from_<6D>s
ryc
Cs
t<00><00>
dS)
N)
r(rrrr<00>as_<73>s
rzc
Cs
t<00><00>
dS)
N)
r(rrrr<00>exists<74>s
r{c


Cs
t<00><00>
dS)
N)
r()
<01>
arrr<00>istrue<75>s
r}c


Cs
t<00><00>
dS)
N)
r()
r|rrr<00>isfalse<73>s
r~cCs
|j|
<00>
S)
N)
rU)r|<00>
brrrrU<00>s
rUcCs
|j|
<00>
S)
N)
rV)r|rrrrrV<00>s
rVcCs
|j|
<00>
S)
N)
rf)r|rrrrrf<00>s
rfcCs|j|
<00>
|<00>
S)
N)
r')r|r$rrrrr'<00>s
r'NcCs|j|
d
|<00>

S)NrH)
rJ)r|rrHrrrrI<00>s
rIcCs|j|
d
|<00>

S)NrH)
rR)r|rrHrrrrQ<00>s
rQcCs|j|
d
|<00>

S)NrH)
rL)r|rrHrrrrK<00>s
rKcCs|j|
d
|<00>

S)NrH)
rT)r|rrHrrrrS<00>s
rSFcCs|j|
|d
|<00>
S)Nrl)
rn)r|r<00>
crlrrrrm<00>s
rmcCs|j|
|d
|<00>
S)Nrl)
Z
notbetween)r|rr<>rlrrr<00>
notbetween_op<6F>s
r<>cCs
|j|
<00>
S)
N)
rN)r|rrrrrM<00>s
rMcCs
|j|
<00>
S)
N)
rP)r|rrrrrO<00>s
rOc


Cs
|j<00>S)
N)
rp)
r|rrrro<00>s
rocCs|j|
d
|<00>

S)NrH)
rX)r|rrHrrrrW<00>s
rWcCs|j|
d
|<00>

S)NrH)
rX)r|rrHrrr<00>notstartswith_op<6F>s
r<>cCs|j|
d
|<00>

S)NrH)
rZ)r|rrHrrrrY<00>s
rYcCs|j|
d
|<00>

S)NrH)
rZ)r|rrHrrr<00>notendswith_ops
r<>cCs|j|
d
|<00>

S)NrH)
r)r|rrHrrrr[s
r[cCs|j|
d
|<00>

S)NrH)
r)r|rrHrrr<00>notcontains_op
s
r<>cKs|j|
|<00>
S)
N)
r])r|rr8rrrr\s
r\cKs|j|
|<00>
S)
N)
Znotmatch)r|rr8rrr<00>notmatch_ops
r<>c
Cs
t<00><00>
dS)
N)
r()r|rrrr<00>comma_ops
r<>cCs
|j|
<00>
S)
N)
rG)r|rrrrrFs
rFc


Cs
|j<00>S)
N)
r_)
r|rrrr^s
r^c


Cs
|j<00>S)
N)
ra)
r|rrrr`"s
r`c


Cs
|j<00>S)
N)
rc)
r|rrrrb&s
rbc


Cs
|j<00>S)
N)
re)
r|rrrrd*s
rdc

Cs"|tkp!t
|t<00>o!|jS)
N)<04>_comparisonr2r#r&)
r'rrrr&3s

r&c

Cs
|tkS)
N)
<01>_commutative)
r'rrr<00>is_commutative8s
r<>c

Cs|tt
ttfkS)
N)r`r^rbrd)
r'rrr<00>is_ordering_modifier<s
	
r<><00>_asbool<6F>	canonical<61>
<00>	_smallest<73>d<00>_largest<73><00><00><00><00><00><00>
<00>cCsZ||
kr|tkrd
St
j|t|dt<00><00>t
j|
t|
dt<00><00>k
SdS)NFr%)<06>_natural_self_precedent<6E>_PRECEDENCE<43>get<65>getattrr<72>r<>)r!r"rrr<00>is_precedent<6E>s

	

	
r<>)Lr/<00>rr!rrrrrr	r
rrr
rrrrrrrrrZpy2kr<00>objectrr#r:ryrzr{r}r~rUrVrfr'rIrQrKrSrmr<>rMrOrorWr<>rYr<>r[r<>r\r<>r<>rFr^r`rbrd<00>setr<74>r<>r&r<>r<><00>unionZ_associativer<65><00>symbolr<6C>r<>r<>r<>r<>rrrr<00><module>s<>|	
<16>$<16><00>$