def METHOD_NAME(self, q1, q2, side="right", affine=True):
    r"""
    Return the Demazure Lusztig operators acting on ``self``.
    INPUT:
    - ``q1,q2`` -- two elements of the ground ring `K`
    - ``side`` -- ``"left"`` or ``"right"`` (default: ``"right"``);
      which side to act upon
    - ``affine`` -- a boolean (default: ``True``)
    The Demazure-Lusztig operator `T_i` is the linear map
    `R \to R` obtained by interpolating between the
    simple projection `\pi_i` (see
    :meth:`CoxeterGroups.ElementMethods.simple_projection`)
    and the simple reflection `s_i` so that `T_i` has
    eigenvalues `q_1` and `q_2`:
    .. MATH::
        (q_1 + q_2) \pi_i - q_2 s_i.
    The Demazure-Lusztig operators give the usual
    representation of the operators `T_i` of the `q_1,q_2`
    Hecke algebra associated to the Coxeter group.
    For a finite Coxeter group, and if ``affine=True``, the
    Demazure-Lusztig operators `T_1,\dots,T_n` are completed
    by `T_0` to implement the level `0` action of the affine
    Hecke algebra.
    EXAMPLES::
        sage: W = WeylGroup(["B",3])
        sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word())
        sage: K = QQ['q1,q2']
        sage: q1, q2 = K.gens()
        sage: KW = W.algebra(K)
        sage: T = KW.demazure_lusztig_operators(q1, q2, affine=True)
        sage: x = KW.monomial(W.an_element()); x
        123
        sage: T[0](x)
        (-q2)*323123 + (q1+q2)*123
        sage: T[1](x)
        q1*1231
        sage: T[2](x)
        q1*1232
        sage: T[3](x)
        (q1+q2)*123 + (-q2)*12
        sage: T._test_relations()
    .. NOTE::
        For a finite Weyl group `W`, the level 0 action of the
        affine Weyl group `\tilde W` only depends on the
        Coxeter diagram of the affinization, not its Dynkin
        diagram. Hence it is possible to explore all cases
        using only untwisted affinizations.
    """
    from sage.combinat.root_system.hecke_algebra_representation import HeckeAlgebraRepresentation
    W = self.basis().keys()
    cartan_type = W.cartan_type()
    if affine and cartan_type.is_finite():
        cartan_type = cartan_type.affine()
    T_on_basis = functools.partial(self.demazure_lusztig_operator_on_basis, q1=q1, q2=q2, side=side)
    return HeckeAlgebraRepresentation(self, T_on_basis, cartan_type, q1, q2)