Genera variantes de preguntas de opción múltiple cuyas respuestas correctas se determinan automáticamente mediante cálculo proposicional. Combina supuestos (hipótesis) y cuestiones (opciones de respuesta) por combinatoria, calcula la veracidad o falsedad de cada cuestión según las hipótesis activas y exporta el resultado a LaTeX (AMC) o Moodle (XML vía LaTeX).

Construido sobre calcprop.

Instalación

Conviene instalar dentro de un entorno virtual (en Debian, Ubuntu o con el Python de Homebrew, pip fuera de uno da externally-managed-environment):

python3 -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install calcprop-qbank       # instala también calcprop

El Manual (sección «Instalación paso a paso») lo explica despacio, también para Windows.

Con soporte para el editor visual en Jupyter:

pip install "calcprop-qbank[jupyter]"

qbank-init y lint llegan con la 0.6.0: si pip te deja una versión anterior (python -c "import qbank; print(qbank.__version__)" falla o da menos de 0.6), actualiza con pip install -U calcprop-qbank. La versión en desarrollo se instala desde el repositorio:

pip install "calcprop-qbank[jupyter] @ git+https://github.com/mbujosab/calcprop-qbank"

Esa orden necesita git instalado. El paquete solo instala el código. El tutorial (Tutorial.ipynb), la guía de diseño (GuiaDiseno.org y su versión impresa GuiaDiseno.pdf), el manual (Manual.org, Manual.pdf) y los ejemplos de ejemplosManual/ están en el repositorio: clónalo con git clone https://github.com/mbujosab/calcprop-qbank o abre el tutorial sin instalar nada con la insignia de MyBinder de arriba. La guía y el manual se leen también en la web, mbujosab.github.io/calcprop-qbank.

Crear un banco de preguntas

La forma recomendada de empezar es la plantilla de proyecto que se distribuye con el paquete (qbank-init necesita la versión 0.6 o posterior):

qbank-init mi-banco
cd mi-banco
make lint          # comprueba las preguntas de ejemplo (sin LaTeX)
make amc           # PDF de revisión (vista profe) en build/amc/

El proyecto contiene cinco preguntas de ejemplo en preguntas/, los scripts que las exportan a AMC y Moodle, un Makefile (lint, tabla, amc, amc-student, moodle, lectura, clean, filtro LECCION=N), nueva_pregunta.py, un guion para escribir una pregunta en Python y guardarla como JSON, y en prompts/ las instrucciones para escribir preguntas con ayuda de una IA. Su README.org explica el flujo.

make usa el intérprete python3 del sistema. Si instalaste qbank en un entorno virtual, actívalo antes (source .venv/bin/activate) o indícalo con PYTHON: make lint PYTHON=/ruta/al/.venv/bin/python. Si ese intérprete no tiene qbank 0.6 o posterior, make se para y lo dice.

Uso rápido

from qbank import *

p = ProblemaTipo(
    [
        "Sea $f$ una función ",
        [   # mundos alternativos: en cada variante se sortea uno
            Supuesto("estrictamente creciente", v('crec')),
            Supuesto("estrictamente decreciente", v('decr')),
        ],
        " y sean $a < b$. Entonces:",
        [   # hueco 1: el alumno ve una de estas dos
            Cuestion("$f(a) < f(b)$", v('crec')),
            Cuestion("$f(a) > f(b)$", v('decr')),
        ],
        Cuestion("$f(a) = f(b)$", False),              # hueco 2: siempre
        [   # hueco 3
            Cuestion("$f(b) - f(a) > 0$", v('crec')),
            Cuestion("$f(b) - f(a) < 0$", v('decr')),
        ],
    ],
    export={"last_choice": True},   # + «Ninguna de las anteriores»
)

for etiqueta, partes in p.por_partes():
    for enunciado, cuestiones in partes:
        print(f"Variante {etiqueta}: {enunciado}")
        for texto, correcto, activa, exp in cuestiones:
            print(f"  {'✓' if correcto else '✗'} {texto}")

Ocho variantes (pocas para un banco real: lint lo avisa), cada una con tres opciones más la opción por defecto («Ninguna de las anteriores», correcta solo si las otras tres son falsas). Una lista de Cuestion sortea una por variante; el alumno ve tantas opciones como elementos-Cuestion consecutivos haya (GuiaDiseno.org lo explica).

Características

Generación combinatoria de variantes

ProblemaTipo toma una lista de supuestos y cuestiones (cada uno con su semántica proposicional) y genera todas las combinaciones posibles. Para cada variante calcula automáticamente qué cuestiones son verdaderas y cuáles falsas. Las variantes con precondiciones insatisfechas se descartan. Las hipótesis contradictorias, en cambio, no se detectan (de ellas se deduce cualquier cosa y todo sale verdadero): se evitan con axiomas como unoDe(v('A'), v('B')).

El método por_partes_profe() muestra todas las cuestiones de cada hueco (marcando las rechazadas por su precondición en vez de descartar la variante), facilitando la revisión del banco.

Preguntas multi-parte

La misma lista plana de componentes admite varias partes: cada vez que tras un bloque de cuestiones aparece texto o un Supuesto se abre una parte nueva. Es útil para preguntas AMC con múltiples apartados o para el formato cloze de Moodle. El método por_partes() devuelve, por variante, un par (enunciado, cuestiones) por parte:

This is the beginning of the README. Read the rest at the original. Read the full README ↗