Skip to content

mcqpy.question.filter

Module for question filters.

Modules:

  • base_filter –

    Module for base-class for question filters.

  • date –

    Date filter for questions.

  • difficulty –

    Module for filtering questions by difficulty level.

  • factory –

    Module for filter factory.

  • manifest –

    Module for manifest-based question filtering.

  • slug –

    Module for slug-based question filtering.

  • stratified –

    Module for stratified question filtering.

  • tag –

    Module for question tag filter.

Classes:

AttributeFilter 

AttributeFilter(
    attribute: str, value: Any, predicate: Callable = None
)

Bases: BaseFilter

Generic filter based on question attributes.

BaseFilter

Bases: ABC

Abstract base class for question filters.

CompositeFilter 

CompositeFilter(filters: list[BaseFilter])

Bases: BaseFilter

Combines multiple filters into a single filter.

DateFilter 

DateFilter(
    date_value: str,
    end_date: str = None,
    strict_missing: bool = True,
)

Bases: BaseFilter

Filter questions by creation date.

Supports:

  • Exact year: DateFilter('2024') - matches all dates in that year
  • Exact date: DateFilter('15/03/2024')
  • Before date: DateFilter('<2024') or DateFilter('<15/03/2024')
  • After date: DateFilter('>2023') or DateFilter('>01/01/2023')
  • Date range: DateFilter('2023', '2024')

Note: All dates are stored internally as dd/mm/yyyy format. Year-only inputs are treated as the full year range (Jan 1 - Dec 31).

Parameters:

  • date_value

    (str) –

    Date string ('yyyy' or 'dd/mm/yyyy'), may include operator prefix

  • end_date

    (str, default: None ) –

    Optional end date for range queries

  • strict_missing

    (bool, default: True ) –

    If True (default), exclude questions without created_date attribute. If False, include questions without created_date attribute.

Methods:

  • apply –

    Apply date filter to questions.

apply 

apply(questions: list[Question]) -> list[Question]

Apply date filter to questions.

DifficultyFilter 

DifficultyFilter(
    difficulty: str,
    operator: Literal["==", "<", "<=", ">", ">="] = "==",
    strict_missing: bool = True,
)

Bases: AttributeFilter

DifficultyFilter for filtering questions by difficulty level.

Filter questions by difficulty level with comparison operators.

Supports:

  • Exact match: DifficultyFilter('hard')
  • Less than: DifficultyFilter('<hard') or DifficultyFilter('hard', operator='<')
  • Less than or equal: DifficultyFilter('<=hard')
  • Greater than: DifficultyFilter('>easy')
  • Greater than or equal: DifficultyFilter('>=easy')

Parameters:

  • difficulty

    (str) –

    Difficulty level to filter by

  • operator

    (Literal['==', '<', '<=', '>', '>='], default: '==' ) –

    Comparison operator.

  • strict_missing

    (bool, default: True ) –

    If True (default), exclude questions without difficulty attribute. If False, include questions without difficulty attribute.

FilterFactory

Creates filters from configuration dictionaries.

Methods:

from_config classmethod 

from_config(config: dict) -> BaseFilter

Create filter from config dict.

ManifestFilter 

ManifestFilter(
    manifest: Manifest | None = None,
    manifest_path: str | None = None,
    exclude: bool = True,
)

Bases: BaseFilter

Manifest file based filter for questions.

Filter questions based on a manifest file.

The primary use case is to exclude questions that are listed in a manifest, such as questions used in a previous exam/quiz.

Parameters:

  • manifest

    (Manifest | None, default: None ) –

    An instance of Manifest. If provided, it will be used directly.

  • manifest_path

    (str | None, default: None ) –

    Path to the manifest file. Used if manifest is None.

  • exclude

    (bool, default: True ) –

    If True, questions in the manifest are excluded.

SlugFilter 

SlugFilter(slugs: list[str] | str)

Bases: AttributeFilter

Filter questions by slug with exact match.

Parameters:

  • slugs

    (list[str] | str) –

    Slugs to filter by

StratifiedFilter 

StratifiedFilter(
    number_of_questions: int,
    filters: list[BaseFilter] | None = None,
    proportions: list[float] | None = None,
    filter_configs: list[dict] | None = None,
)

Bases: BaseFilter

Stratified selection filter

Stratified filter to select questions based on multiple filters and specified proportions.

Parameters:

  • number_of_questions

    (int) –

    Total number of questions to select.

  • filters

    (list[BaseFilter] | None, default: None ) –

    List of BaseFilter instances to apply.

  • proportions

    (list[float] | None, default: None ) –

    List of proportions corresponding to each filter.

  • filter_configs

    (list[dict] | None, default: None ) –

    List of filter configuration dictionaries to create filters if filters is None.

TagFilter 

TagFilter(
    tags: list[str] | str,
    match_all: bool = False,
    exclude: bool = False,
    strict_missing: bool = True,
)

Bases: AttributeFilter

Filter questions by tag(s).

Supports:

  • Include any: TagFilter(['python', 'loops'])
  • Include all: TagFilter(['python', 'loops'], match_all=True)
  • Exclude any: TagFilter(['deprecated'], exclude=True)

Parameters:

  • tags

    (list[str] | str) –

    Tag(s) to filter by.

  • match_all

    (bool, default: False ) –

    If True, question must have all specified tags.

  • exclude

    (bool, default: False ) –

    If True, exclude questions with any of the specified tags.

  • strict_missing

    (bool, default: True ) –

    If True (default), exclude questions without tags attribute (unless exclude=True). If False, include questions without tags attribute (unless exclude=True).