How to use the pyromaths.ex.TexExercise function in pyromaths

if __name__ == '__main__':
    from pyromaths.outils import Priorites3

    pass

def racines(p, lracines):
    """ Trouve les 2 racines manquantes d'un polynôme de degré 5 connaissant 3 des racines
    """
    q = Polynome(p)
    for r in lracines:
        q = q // Polynome("x-%s" % r)
    delta = q[1][0] ** 2 - 4 * q[0][0] * q[2][0]
    d = float(eval(Priorites3.priorites(delta)[-1][0]))
    return (-float(q[1][0]) + sqrt(d)) / 2 / float(q[0][0]), (-float(q[1][0]) - sqrt(d)) / 2 / float(q[0][0])

class EquationGraphique(ex.TexExercise):
    # description = _(u'Résolution graphique d\'équations')
    # level = _(u"2.Seconde")

    def __init__(self):
        """
        l1, l2 et l3 sont les abscisses remarquables,
        y1, y2 et y3 sont les ordonnées correspondantes

        l1 contient trois abscisses de même ordonnée
        l2 contient deux abscisses de même ordonnée
        l3 contient 2 abscisses séparées d'un dixième (un extremum local j'espère) de même ordonnée
        """
        End = False
        while End == False:
            encore = True
            while encore:

exercice.append([pol, val[1], val[2]])

        self.exercice = exercice

    def tex_statement(self):
        exo = [r'\exercice']
        exo.append(r'\begin{enumerate}')
        exo.append(_(u'\\item Déterminer le signe du polynôme $P\\,(x) = %s$') % Polynome(self.exercice[0]))
        exo.append(_(u'\\item Le polynôme $Q\\,(x) = %s$ admet deux racines $%s$ et $%s\\,$. Dresser son tableau de signes.') \
            % (Polynome(self.exercice[1][0]), self.exercice[1][1], self.exercice[1][2]))
        exo.append(_(u'\\item Le polynôme $R\\,(x) = %s$ admet deux racines $%s$ et $%s\\,$. Dresser son tableau de signes.') \
            % (Polynome(self.exercice[2][0]), self.exercice[2][1], self.exercice[2][2]))
        exo.append('\\end{enumerate}')
        return exo

class Sd3bInequations(ex.TexExercise):
    # description = u'Inéquations et polynômes de degré 2'
    level = _(u"1.1èreS")
    def __init__(self):
        pol = creerPolydegre2(nb_racines=2, rac_radical=False, rac_quotient=False).monomes
        pol2 = [[valeur_alea(-9, 9), 1], [valeur_alea(-9, 9), 0]]
        shuffle(pol)
        shuffle(pol2)
        p = [pol, pol2]
        shuffle(p)
        p.append(['<', '>', '\\le', '\\ge'][randrange(4)])
        self.exercice = p

    def tex_statement(self):
        exo = [r'\exercice']
        exo.append(_(u'Résoudre l\'inéquation : $\qquad \\cfrac{%s}{%s} %s 0$') % (Polynome(self.exercice[0]),
                                                                                  Polynome(self.exercice[1]),

# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
from random import randint, shuffle
import textwrap

from pyromaths import ex
from pyromaths.outils.Affichage import decimaux

precision = [u'au millième', u'au centième', u'au dixième', u'à l\'unité',
             u'à la dizaine', u'à la centaine', 'au millier',
             u'à la dizaine de milliers']

supinf = ['', u' par défaut', u' par excès']

class ArrondirNombreDecimal(ex.TexExercise):
    """ Exercice d'arrondis avec les encadrements. """

    description = u'Arrondir des nombres décimaux'

    def __init__(self):
        hasard = [valide_hasard() for dummy in range(4)]
        choix = [(i, j) for i in range(7)  for j in range(3)]
        shuffle(choix)
        self.choix_precision = [choix[i][0] for i in range(4)]
        self.choix_supinf = [choix[i][1] for i in range(4)]
    # FIXME
        # Arrondir n'est pas synonyme de valeur approchée
        # Valeur approchée par excès 
        # Valeur approchée par défaut 
        # Arrondi = la « meilleure » valeur approchée
        # et ne paraît employé ici correctement

#
'''
Created on 21 janv. 2015

@author: jerome
'''
from pyromaths import ex
from random import randrange
def listeToclasses(liste):
    result = [r'$[%s' % (liste[0])]
    for l in liste[1:]:
        result.append(r'$[%s' % (l + eval(result[-1][2:])))
        result[-2] = result[-2] + r' ~;~ %s[$' % (l + eval(result[-2][2:]))
    result.pop(-1)
    return result
class Histogramme(ex.TexExercise):
    '''
    classdocs
    '''
    # description = u'Construire un histogramme'
    # level = u"2.Seconde"


    def __init__(self):
        '''
        Constructor
        '''
        echelle1 = 5 * 2 ** randrange(1, 6)
        debut = randrange(0, 4) * 10 ** randrange(0, 4)
        classes = [debut]
        classes.extend([echelle1 * randrange(1, 5) for dummy in range(randrange(4, 6))])
        echelle2 = 5 * 2 ** randrange(1, 6)

# -*- coding: utf-8 -*-
from pyromaths import ex

class HelloWorld(ex.TexExercise):

    # Un-comment to show this exercise:
#    description = u'Exemple HelloWorld'

    def tex_statement(self):
        return ['\\exercice', 'Hello, world!']

    def tex_answer(self):
        return ['\\exercice*', _('Hello, world corrigé!')]

extr = extrema(self.lX, self.lY2, [self.lX[0], self.lX[-1]])
        exo.append(u'\\item ')
        exo.append(r'\begin{itemize}[leftmargin=*]')
        exo.append(_(u'\\item Sur $[%s~;~%s]$ , le \\textbf{maximum} de $g$ est $y = %s$. Il est \\textbf{atteint en} $x = %s$.') % (self.lX[0], self.lX[-1], extr[1][1], extr[1][0]))
        exo.append(_(u'\\item Sur $[%s~;~%s]$ , le \\textbf{minimum} de $g$ est $y = %s$. Il est \\textbf{atteint en} $x = %s$.') % (self.lX[0], self.lX[-1], extr[0][1], extr[0][0]))
        exo.append(r'\end{itemize}')
        extr = extrema(self.lX, self.lY2, self.intervalle2)
        exo.append(u'\\item ')
        exo.append(r'\begin{itemize}[leftmargin=*]')
        exo.append(_(u'\\item Sur $[%s~;~%s]$ , le \\textbf{maximum} de $g$ est $y = %s$. Il est \\textbf{atteint en} $x = %s$.') % (self.intervalle2[0], self.intervalle2[1], extr[1][1], extr[1][0]))
        exo.append(_(u'\\item Sur $[%s~;~%s]$ , le \\textbf{minimum} de $g$ est $y = %s$. Il est \\textbf{atteint en} $x = %s$.') % (self.intervalle2[0], self.intervalle2[1], extr[0][1], extr[0][0]))
        exo.append(r'\end{itemize}')
        exo.append(r'\end{enumerate}')
        return exo

class Vf3VariationVersCourbe(ex.TexExercise):
    description = _(u'Tableaux de variations et courbe')
    level = _(u"2.Seconde")

    def __init__(self):
        lX = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
        self.lX = list(lX)
        self.lY1, self.variations1 = PointsCourbes(sens_var=(-1, 1))
        self.lY2, self.variations2 = PointsCourbes()

    def tex_statement(self):
        exo = [r'\exercice']
        exo.append(r'\begin{enumerate}')
        exo.append(_(u'\\item Pour chaque question, répondre avec une phrase en précisant les intervalles.\\vspace{-2ex}'))
        exo.append(r'\begin{multicols}{2}')
        exo.append(r'\begin{enumerate}')
        exo.append(_(u'\\item Quel est le signe de la fonction $f$ ?'))

c = c.numerator
            if b.denominator != 1:
                b = 'Fraction(%s, %s)' % (b.numerator, b.denominator)
            else:
                b = b.numerator
        return Polynome([[a, 2], [b, 1], [c, 0]])
    elif nb_racines == 1:
        a, b = valeur_alea(-9, 9), valeur_alea(-9, 9)
        return Polynome([[a ** 2, 2], [2 * a * b, 1], [b ** 2, 0]])
    else:
        pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
        while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
            pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
        return Polynome(pol)

class Sd1FormeCanonique(ex.TexExercise):

    description = _(u'Forme canonique')
    level = _(u"1.1èreS")

    def __init__(self):
        m = [[1, 2], [2 * randrange(1, 10) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
        pol = [[['Polynome(%s, "x", details=0)' % m]]]
        pol[0].extend(self.resolution(m))
        m = [[1, 2], [(2 * randrange(1, 6) + 1) * (-1) ** randrange(2), 1], [randrange(1, 10) * (-1) ** randrange(2), 0]]
        pol.append([['Polynome(%s, "x", details=0)' % m]])
        pol[1].extend(self.resolution(m))
        a, b = randrange(1, 10), randrange(1, 10)
        m = [[a ** 2, 2], [2 * a * b * (-1) ** randrange(2), 1], [b ** 2, 0]]
        pol.append([['Polynome(%s, "x", details=0)' % m]])
        if m[1][0] < 0: pol[2].extend(self.id_rem(a, b, '-'))
        else: pol[2].extend(self.id_rem(a, b, '+'))

lp.append(pol)
        shuffle(lp)

        self.exercice = lp

    def tex_statement(self):
        exo = [r'\exercice']
        exo.append(_(u'On donne les polynômes $\\quad p\\,(x) = %s \\quad$ et $\\quad Q\\,(x) = %s$.') % (self.exercice[0], self.exercice[1]))
        exo.append(r'\begin{enumerate}')
        exo.append(_(u'\\item Donner les caractéristiques de leurs courbes respectives (sommet, intersections avec les axes du repère).'))
        exo.append(_(u'\\item Tracer l’allure de ces deux courbes sur un même graphique.'))
        exo.append(r'\end{enumerate}')

        return exo

class Sd6Parametre(ex.TexExercise):
    # description = u'Polynôme paramétré de degré 2'
    level = _(u"1.1èreS")
    def __init__(self):
        [a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
        while a == 0 or c == 0 or a ** 2 * d - a * b * c + c ** 2 < 0 or carrerise(a ** 2 * d - a * b * c + c ** 2) != 1:
            [a, b, c, d] = [randrange(-5, 6) for dummy in range(4)]
        p1 = str(Polynome([[a, 1], [b, 0]], "m"))
        p2 = str(Polynome([[c, 1], [d, 0]], "m"))
        pol = [Polynome([[1, 2], [p1, 1], [p2, 0]]), randrange(3)]
        exercice = [list(pol)]

        v = [randrange(-4, 5) for dummy in range(6)]
        while v[0] == 0 or v[2] == v[4] == 0 or reduce(lambda x, y: x * y, v) != 0 or v[2] == v[3] == 0 or v[4] == v[5] == 0:
            v = [randrange(-4, 5) for dummy in range(6)]
        lp = [str(Polynome([[v[2 * i] / pgcd(v[2 * i], v[2 * i + 1]), 1], [v[2 * i + 1] / pgcd(v[2 * i], v[2 * i + 1]), 0]], "a")) for i in range(3)]
        pol = Polynome([[lp[0], 2], [lp[1], 1], [lp[2], 0]])

lpoints = []
            cpt = 0
        lpoints = cree_angles(nb_angles, xmax, ymax)
        cpt = cpt + 1
    tmpl = Geometrie.choix_points(3 * nb_angles)
    for i in range(nb_angles):
        lnoms.append(tuple(tmpl[3 * i:3 * i + 3]))
    exo = ["\\exercice", "Nommer, mesurer et donner la nature de chacun des angles suivants :\\par "]
    cor = ["\\exercice*", "Nommer, mesurer et donner la nature de chacun des angles suivants :\\par "]
    figure(exo, cor, lpoints, lnoms, xmax, ymax)
    reponses(exo, cor, lpoints, lnoms)
    return (exo, cor)

MesureAngles.description = u'Mesurer des angles'

class ConstruireZigZag(ex.TexExercise):

    description = u'Construire des angles'

    def __init__(self):
        """ Crée une liste de nbp points situés à la distance lg les uns des
        autres"""
        from pyromaths.outils.Conversions import radians
        from math import sin, cos
        self.lg, nbp = 4, 6
        fini = False
        while not fini:
            ar = randrange(80, 91)
            angles_relatifs = [ar]
            angles_absolus = [ar]
            ar = radians(ar)
            points = [(.2, .2), (.2 + self.lg * cos(ar), .2 + self.lg * sin(ar))]

self.exercice = exercice

    def tex_statement(self):
        exo = [r'\exercice']
        exo.append(_(u'Résoudre les équations :'))
        exo.append('\\begin{align*}')
        for e in self.exercice:
            if len(e) == 2:
                exo.append(Priorites3.texify([[repr(Polynome(e[0])), '*', repr(Polynome(e[1]))]])[0] + ' &= 0 & ')
            else:
                exo.append(r'\cfrac{%s}{%s} &= %s & ' % (Polynome(e[0]), Polynome(e[1]), Polynome(e[2])))
        exo[-1] = exo[-1][:-3]  # Suppression du dernier  " &"
        exo.append('\\end{align*}')
        return exo

class Sd3aSigne(ex.TexExercise):
    # description = u'Signe d\'un polynôme de degré 2'
    level = _(u"1.1èreS")
    def __init__(self):
        pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
        while pol[1][0] ** 2 - 4 * pol[0][0] * pol[2][0] >= 0:
            pol = [[valeur_alea(-9, 9), 2 - dummy] for dummy in range(3)]
        exercice = [list(pol)]

        val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
        val.append(Fraction(valeur_alea(-9, 9), val[0]))
        while val[2].d == 1:
            val = [valeur_alea(-9, 9), valeur_alea(-9, 9)]
            val.append(Fraction(valeur_alea(-9, 9), val[0]))
        sgn = -val[0] / abs(val[0])
        pol = [[val[0], 2], [(-val[0] * (val[1] * val[2].d + val[2].n)) / val[2].d, 1], [(val[0] * val[1] * val[2].n) / val[2].d, 0]]
        shuffle(pol)