QuizGenerator 0.4.2__py3-none-any.whl

QuizGenerator/performance.py

@@ -0,0 +1,202 @@
+"""
+Performance instrumentation for quiz generation and Canvas upload pipeline.
+
+This module provides timing instrumentation to identify bottlenecks in:
+1. Question generation (refresh, get_body, get_explanation)
+2. AST rendering for Canvas
+3. Canvas API uploads
+
+Usage:
+    from QuizGenerator.performance import PerformanceTracker, timer
+
+    # Use context manager
+    with timer("operation_name"):
+        # your code here
+
+    # Access metrics
+    metrics = PerformanceTracker.get_metrics()
+    PerformanceTracker.report_summary()
+"""
+
+import time
+import statistics
+import logging
+from contextlib import contextmanager
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field
+from collections import defaultdict
+
+log = logging.getLogger(__name__)
+
+@dataclass
+class TimingMetric:
+    """Container for timing measurements"""
+    operation: str
+    duration: float
+    question_name: Optional[str] = None
+    question_type: Optional[str] = None
+    variation_number: Optional[int] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class PerformanceTracker:
+    """Global performance tracking system"""
+
+    _metrics: List[TimingMetric] = []
+    _active_timers: Dict[str, float] = {}
+
+    @classmethod
+    def start_timer(cls, operation: str, **metadata) -> str:
+        """Start a named timer and return a timer ID"""
+        timer_id = f"{operation}_{time.time()}"
+        cls._active_timers[timer_id] = time.perf_counter()
+        return timer_id
+
+    @classmethod
+    def end_timer(cls, timer_id: str, operation: str, **metadata) -> float:
+        """End a timer and record the metric"""
+        if timer_id not in cls._active_timers:
+            log.warning(f"Timer {timer_id} not found")
+            return 0.0
+
+        start_time = cls._active_timers.pop(timer_id)
+        duration = time.perf_counter() - start_time
+
+        metric = TimingMetric(
+            operation=operation,
+            duration=duration,
+            **metadata
+        )
+        cls._metrics.append(metric)
+
+        log.debug(f"{operation}: {duration:.3f}s {metadata}")
+        return duration
+
+    @classmethod
+    def record_timing(cls, operation: str, duration: float, **metadata):
+        """Record a timing metric directly"""
+        metric = TimingMetric(
+            operation=operation,
+            duration=duration,
+            **metadata
+        )
+        cls._metrics.append(metric)
+
+    @classmethod
+    def get_metrics(cls) -> List[TimingMetric]:
+        """Get all recorded metrics"""
+        return cls._metrics.copy()
+
+    @classmethod
+    def get_metrics_by_operation(cls, operation: str) -> List[TimingMetric]:
+        """Get metrics filtered by operation name"""
+        return [m for m in cls._metrics if m.operation == operation]
+
+    @classmethod
+    def clear_metrics(cls):
+        """Clear all recorded metrics"""
+        cls._metrics.clear()
+        cls._active_timers.clear()
+
+    @classmethod
+    def get_summary_stats(cls, operation: str) -> Dict[str, float]:
+        """Get summary statistics for an operation"""
+        metrics = cls.get_metrics_by_operation(operation)
+        if not metrics:
+            return {}
+
+        durations = [m.duration for m in metrics]
+        return {
+            'count': len(durations),
+            'total': sum(durations),
+            'mean': statistics.mean(durations),
+            'median': statistics.median(durations),
+            'min': min(durations),
+            'max': max(durations),
+            'std': statistics.stdev(durations) if len(durations) > 1 else 0
+        }
+
+    @classmethod
+    def report_summary(cls, min_duration: float = 0.001) -> str:
+        """Generate a summary report of all operations"""
+        operations = set(m.operation for m in cls._metrics)
+
+        report_lines = []
+        report_lines.append("=== Performance Summary Report ===")
+        report_lines.append(f"Total metrics recorded: {len(cls._metrics)}")
+        report_lines.append("")
+
+        # Group by operation
+        for operation in sorted(operations):
+            stats = cls.get_summary_stats(operation)
+            if stats['mean'] < min_duration:  # Skip very fast operations
+                continue
+
+            report_lines.append(f"{operation}:")
+            report_lines.append(f"  Count: {stats['count']}")
+            report_lines.append(f"  Total: {stats['total']:.3f}s")
+            report_lines.append(f"  Mean:  {stats['mean']:.3f}s ± {stats['std']:.3f}s")
+            report_lines.append(f"  Range: {stats['min']:.3f}s - {stats['max']:.3f}s")
+            report_lines.append("")
+
+        report = '\n'.join(report_lines)
+        print(report)
+        return report
+
+    @classmethod
+    def report_detailed(cls, operation: Optional[str] = None) -> str:
+        """Generate detailed report showing individual measurements"""
+        metrics = cls.get_metrics_by_operation(operation) if operation else cls._metrics
+
+        report_lines = []
+        if operation:
+            report_lines.append(f"=== Detailed Report: {operation} ===")
+        else:
+            report_lines.append("=== Detailed Report: All Operations ===")
+
+        # Group by question if available
+        by_question = defaultdict(list)
+        for metric in metrics:
+            key = metric.question_name or "unknown"
+            by_question[key].append(metric)
+
+        for question_name, question_metrics in by_question.items():
+            report_lines.append(f"\nQuestion: {question_name}")
+            for metric in sorted(question_metrics, key=lambda m: m.variation_number or 0):
+                metadata_str = ""
+                if metric.question_type:
+                    metadata_str += f" [{metric.question_type}]"
+                if metric.variation_number is not None:
+                    metadata_str += f" var#{metric.variation_number}"
+
+                report_lines.append(f"  {metric.operation}: {metric.duration:.3f}s{metadata_str}")
+
+        report = '\n'.join(report_lines)
+        print(report)
+        return report
+
+@contextmanager
+def timer(operation: str, **metadata):
+    """Context manager for timing operations"""
+    timer_id = PerformanceTracker.start_timer(operation, **metadata)
+    try:
+        yield
+    finally:
+        PerformanceTracker.end_timer(timer_id, operation, **metadata)
+
+def timed_method(operation_name: Optional[str] = None):
+    """Decorator for timing method calls"""
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            op_name = operation_name or f"{func.__name__}"
+
+            # Try to extract question info from self if available
+            metadata = {}
+            if args and hasattr(args[0], 'name'):
+                metadata['question_name'] = getattr(args[0], 'name', None)
+            if args and hasattr(args[0], '__class__'):
+                metadata['question_type'] = args[0].__class__.__name__
+
+            with timer(op_name, **metadata):
+                return func(*args, **kwargs)
+        return wrapper
+    return decorator

QuizGenerator/premade_questions/basic.py

@@ -0,0 +1,103 @@
+#!env python
+from __future__ import annotations
+
+from typing import List, Dict, Any, Tuple
+
+import logging
+
+from QuizGenerator.contentast import *
+from QuizGenerator.question import Question, QuestionRegistry, Answer
+from QuizGenerator.mixins import TableQuestionMixin
+
+log = logging.getLogger(__name__)
+
+
+@QuestionRegistry.register()
+class FromText(Question):
+  
+  def __init__(self, *args, text, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.text = text
+    self.answers = []
+    self.possible_variations = 1
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    
+    return ContentAST.Section([ContentAST.Text(self.text)])
+  
+  def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:
+    return Answer.AnswerKind.ESSAY, []
+
+
+@QuestionRegistry.register()
+class FromGenerator(FromText, TableQuestionMixin):
+  
+  def __init__(self, *args, generator=None, text=None, **kwargs):
+    if generator is None and text is None:
+      raise TypeError(f"Must supply either generator or text kwarg for {self.__class__.__name__}")
+    
+    if generator is None:
+      generator = text
+    
+    super().__init__(*args, text="", **kwargs)
+    self.possible_variations = kwargs.get("possible_variations", float('inf'))
+    
+    def attach_function_to_object(obj, function_code, function_name='get_body_lines'):
+      function_code = "import random\n" + function_code
+
+      # Create a local namespace for exec with ContentAST available
+      local_namespace = {
+        'ContentAST': ContentAST,
+        'Section': ContentAST.Section,
+        'Text': ContentAST.Text,
+        'Table': ContentAST.Table,
+        'Paragraph': ContentAST.Paragraph
+      }
+
+      # Define the function dynamically using exec
+      # Merge current globals with our local namespace for the exec
+      exec_globals = {**globals(), **local_namespace}
+      exec(f"def {function_name}(self):\n" + "\n".join(f"    {line}" for line in function_code.splitlines()), exec_globals, local_namespace)
+
+      # Get the function and bind it to the object
+      function = local_namespace[function_name]
+      setattr(obj, function_name, function.__get__(obj))
+    
+    self.generator_text = generator
+    # Attach the function dynamically
+    attach_function_to_object(self, generator, "generator")
+    
+    self.answers = {}
+
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    return super().get_body()
+
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    try:
+      generated_content = self.generator()
+      # Expect generator to return a ContentAST.Section or convert string to Section
+      if isinstance(generated_content, ContentAST.Section):
+        self.text = ""  # Clear text since we'll override get_body
+        self._generated_section = generated_content
+      elif isinstance(generated_content, str):
+        self.text = generated_content
+        self._generated_section = None
+      else:
+        # Fallback
+        self.text = str(generated_content)
+        self._generated_section = None
+    except TypeError as e:
+      log.error(f"Error generating from text: {e}")
+      log.debug(self.generator_text)
+      exit(8)
+
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    if hasattr(self, '_generated_section') and self._generated_section:
+      return self._generated_section
+    return super().get_body()
+
+
+class TrueFalse(FromText):
+  pass

QuizGenerator/premade_questions/cst334/__init__.py

@@ -0,0 +1 @@
+# CST334 Operating Systems questions

QuizGenerator/premade_questions/cst334/languages.py

@@ -0,0 +1,391 @@
+#!env python
+from __future__ import annotations
+
+import abc
+import enum
+import itertools
+from typing import List, Dict, Optional, Tuple, Any
+
+from QuizGenerator.question import QuestionRegistry, Question, Answer
+
+from QuizGenerator.contentast import ContentAST
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class LanguageQuestion(Question, abc.ABC):
+  def __init__(self, *args, **kwargs):
+    kwargs["topic"] = kwargs.get("topic", Question.Topic.LANGUAGES)
+    super().__init__(*args, **kwargs)
+
+class BNF:
+  
+  class Grammar:
+    def __init__(self, symbols, start_symbol=None):
+      self.start_symbol = start_symbol if start_symbol is not None else symbols[0]
+      self.symbols = symbols
+  
+    def generate(self, include_spaces=False, early_exit=False, early_exit_min_iterations=5):
+      curr_symbols : List[BNF.Symbol] = [self.start_symbol]
+      prev_symbols: List[BNF.Symbol] = curr_symbols
+      
+      iteration_count = 0
+      # Check to see if we have any non-terminals left
+      while any(map(lambda s: s.kind == BNF.Symbol.Kind.NonTerminal, curr_symbols)):
+        # Grab the previous symbols in case we are early exitting
+        prev_symbols = curr_symbols
+        
+        # Walk through the current symbols and build a new list of symbols from it
+        next_symbols : List[BNF.Symbol] = []
+        for symbol in curr_symbols:
+          next_symbols.extend(symbol.expand())
+        curr_symbols = next_symbols
+        
+        iteration_count += 1
+        
+        if early_exit and iteration_count > early_exit_min_iterations:
+          break
+        
+      if early_exit:
+        # If we are doing an early exit then we are going to return things with non-terminals
+        curr_symbols = prev_symbols
+      
+      # Take all the current symbols and combine them
+      return ('' if not include_spaces else ' ').join([str(s) for s in curr_symbols])
+    
+    def print(self):
+      for symbol in self.symbols:
+        print(symbol.get_full_str())
+        
+    def get_grammar_string(self):
+      lines = []
+      for symbol in self.symbols:
+        lines.append(f"{symbol.get_full_str()}")
+
+      return '\n'.join(lines)
+      
+  class Symbol:
+    
+    class Kind(enum.Enum):
+      NonTerminal = enum.auto()
+      Terminal = enum.auto()
+      
+    def __init__(self, symbol : str, kind : Kind, rng):
+      self.symbol = symbol
+      self.kind = kind
+      self.productions : List[BNF.Production] = [] # productions
+      self.rng = rng
+    
+    def __str__(self):
+      # if self.kind == BNF.Symbol.Kind.NonTerminal:
+      #   return f"`{self.symbol}`"
+      # else:
+      #   return f"{self.symbol}"
+      return f"{self.symbol}"
+    
+    def get_full_str(self):
+      return f"{self.symbol} ::= {' | '.join([str(p) for p in self.productions])}"
+    
+    def add_production(self, production: BNF.Production):
+      self.productions.append(production)
+    
+    def expand(self) -> List[BNF.Symbol]:
+      if self.kind == BNF.Symbol.Kind.Terminal:
+        return [self]
+      return self.rng.choice(self.productions).production
+  
+  class Production:
+    def __init__(self, production_line, nonterminal_symbols: Dict[str, BNF.Symbol], rng):
+      if len(production_line.strip()) == 0:
+        self.production = []
+      else:
+        self.production = [
+          (nonterminal_symbols.get(symbol, BNF.Symbol(symbol, BNF.Symbol.Kind.Terminal, rng=rng)))
+          for symbol in production_line.split(' ')
+        ]
+      
+    def __str__(self):
+      if len(self.production) == 0:
+        return '""'
+      return f"{' '.join([str(s) for s in self.production])}"
+  
+  
+  @staticmethod
+  def parse_bnf(grammar_str, rng) -> BNF.Grammar:
+    
+    # Figure out all the nonterminals and create a Token for them
+    terminal_symbols = {}
+    start_symbol = None
+    for line in grammar_str.strip().splitlines():
+      if "::=" in line:
+        non_terminal_str, _ = line.split("::=", 1)
+        non_terminal_str = non_terminal_str.strip()
+        
+        terminal_symbols[non_terminal_str] = BNF.Symbol(non_terminal_str, BNF.Symbol.Kind.NonTerminal, rng=rng)
+        if start_symbol is None:
+          start_symbol = terminal_symbols[non_terminal_str]
+    
+    # Parse the grammar statement
+    for line in grammar_str.strip().splitlines():
+      if "::=" in line:
+        # Split the line into non-terminal and its expansions
+        non_terminal_str, expansions = line.split("::=", 1)
+        non_terminal_str = non_terminal_str.strip()
+        
+        non_terminal = terminal_symbols[non_terminal_str]
+        
+        for production_str in expansions.split('|'):
+          production_str = production_str.strip()
+          non_terminal.add_production(BNF.Production(production_str, terminal_symbols, rng=rng))
+    bnf_grammar = BNF.Grammar(list(terminal_symbols.values()), start_symbol)
+    return bnf_grammar
+
+
+@QuestionRegistry.register("LanguageQuestion")
+class ValidStringsInLanguageQuestion(LanguageQuestion):
+  MAX_TRIES = 1000
+  
+  def __init__(self, grammar_str_good: Optional[str] = None, grammar_str_bad: Optional[str] = None, *args, **kwargs):
+    # Preserve question-specific params for QR code config
+    if grammar_str_good is not None:
+      kwargs['grammar_str_good'] = grammar_str_good
+    if grammar_str_bad is not None:
+      kwargs['grammar_str_bad'] = grammar_str_bad
+
+    super().__init__(*args, **kwargs)
+
+    if grammar_str_good is not None and grammar_str_bad is not None:
+      self.grammar_str_good = grammar_str_good
+      self.grammar_str_bad = grammar_str_bad
+      self.include_spaces = kwargs.get("include_spaces", False)
+      self.MAX_LENGTH = kwargs.get("max_length", 30)
+    else:
+      which_grammar = self.rng.choice(range(4))
+      
+      if which_grammar == 0:
+        # todo: make a few different kinds of grammars that could be picked
+        self.grammar_str_good = """
+          <expression> ::= <term> | <expression> + <term> | <expression> - <term>
+          <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
+          <factor>     ::= <number>
+          <number>     ::= <digit> | <number> <digit>
+          <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+        """
+        # Adding in a plus to number
+        self.grammar_str_bad = """
+          <expression> ::= <term> | <expression> + <term> | <expression> - <term>
+          <term>       ::= <factor> | <term> * <factor> | <term> / <factor>
+          <factor>     ::= <number>
+          <number>     ::= <digit> + | <digit> <number>
+          <digit>      ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+        """
+        self.include_spaces = False
+        self.MAX_LENGTH = 30
+      elif which_grammar == 1:
+        self.grammar_str_good = """
+          <sentence> ::= <subject> <verb> <object>
+          <subject> ::= The cat | A dog | The bird | A child | <adjective> <animal>
+          <animal> ::= cat | dog | bird | child
+          <adjective> ::= happy | sad | angry | playful
+          <verb> ::= chases | sees | hates | loves
+          <object> ::= the ball | the toy | the tree | <adjective> <object>
+        """
+        self.grammar_str_bad = """
+          <sentence> ::= <subject> <verb> <object>
+          <subject> ::= The human | The dog | A bird | Some child | A <adjective> <animal>
+          <animal> ::= cat | dog | bird | child
+          <adjective> ::= happy | sad | angry | playful
+          <verb> ::= chases | sees | hates | loves
+          <object> ::= the ball | the toy | the tree | <adjective> <object>
+        """
+        self.include_spaces = True
+        self.MAX_LENGTH = 100
+      elif which_grammar == 2:
+        self.grammar_str_good = """
+          <poem> ::= <line> | <line> <poem>
+          <line> ::= <subject> <verb> <object> <modifier>
+          <subject> ::= whispers | shadows | dreams | echoes | <compound-subject>
+          <compound-subject> ::= <subject> and <subject>
+          <verb> ::= dance | dissolve | shimmer | collapse | <compound-verb>
+          <compound-verb> ::= <verb> then <verb>
+          <object> ::= beneath | between | inside | around | <compound-object>
+          <compound-object> ::= <object> through <object>
+          <modifier> ::= silently | violently | mysteriously | endlessly | <recursive-modifier>
+          <recursive-modifier> ::= <modifier> and <modifier>
+        """
+        self.grammar_str_bad = """
+          <bad-poem> ::= <almost-valid-line> | <bad-poem> <bad-poem>
+          <almost-valid-line> ::= <tricky-subject> <tricky-verb> <tricky-object> <tricky-modifier>
+          <tricky-subject> ::= whispers | shadows and and | <duplicate-subject>
+          <duplicate-subject> ::= whispers whispers
+          <tricky-verb> ::= dance | <incorrect-verb-placement> | <verb-verb>
+          <incorrect-verb-placement> ::= dance dance
+          <verb-verb> ::= dance whispers
+          <tricky-object> ::= beneath | <object-verb-swap> | <duplicate-object>
+          <object-verb-swap> ::= dance beneath
+          <duplicate-object> ::= beneath beneath
+          <tricky-modifier> ::= silently | <modifier-subject-swap> | <duplicate-modifier>
+          <modifier-subject-swap> ::= whispers silently
+          <duplicate-modifier> ::= silently silently
+        """
+        self.include_spaces = True
+        self.MAX_LENGTH = 100
+      elif which_grammar == 3:
+        self.grammar_str_good = """
+          <A> ::= a <B> a |
+          <B> ::= b <C> b |
+          <C> ::= c <A> c |
+        """
+        self.grammar_str_bad = """
+          <A> ::= a <B> c
+          <B> ::= b <C> a |
+          <C> ::= c <A> b |
+        """
+        self.include_spaces = False
+        self.MAX_LENGTH = 100
+    
+    self.grammar_good = BNF.parse_bnf(self.grammar_str_good, self.rng)
+    self.grammar_bad = BNF.parse_bnf(self.grammar_str_bad, self.rng)
+    
+    self.num_answer_options = kwargs.get("num_answer_options", 4)
+    self.num_answer_blanks = kwargs.get("num_answer_blanks", 4)
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    
+    self.answers = {}
+    
+    self.num_answer_options = kwargs.get("num_answer_options", 4)
+    self.num_answer_blanks = kwargs.get("num_answer_blanks", 4)
+    
+    self.refresh()
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    
+    self.answers = {}
+    
+    self.answers.update(
+      {
+        "answer_good" : Answer(
+          f"answer_good",
+          self.grammar_good.generate(self.include_spaces),
+          Answer.AnswerKind.MULTIPLE_ANSWER,
+          correct=True
+        )
+      }
+    )
+    
+    self.answers.update(
+      {
+        "answer_bad":
+          Answer(
+            f"answer_bad",
+            self.grammar_bad.generate(self.include_spaces),
+            Answer.AnswerKind.MULTIPLE_ANSWER,
+            correct=False
+          )
+      })
+    self.answers.update({
+      "answer_bad_early":
+        Answer(
+          f"answer_bad_early",
+          self.grammar_bad.generate(self.include_spaces, early_exit=True),
+          Answer.AnswerKind.MULTIPLE_ANSWER,
+          correct=False
+        )
+    })
+    
+    answer_text_set = {a.value for a in self.answers.values()}
+    num_tries = 0
+    while len(self.answers) < 10 and num_tries < self.MAX_TRIES:
+      
+      correct = self.rng.choice([True, False])
+      if not correct:
+        early_exit = self.rng.choice([True, False])
+      else:
+        early_exit = False
+      new_answer = Answer(
+        f"answer_{num_tries}",
+        (
+          self.grammar_good
+          if correct or early_exit
+          else self.grammar_bad
+        ).generate(self.include_spaces, early_exit=early_exit),
+        Answer.AnswerKind.MULTIPLE_ANSWER,
+        correct= correct and not early_exit
+      )
+      if len(new_answer.value) < self.MAX_LENGTH and new_answer.value not in answer_text_set:
+        self.answers.update({new_answer.key : new_answer})
+        answer_text_set.add(new_answer.value)
+      num_tries += 1
+    
+    # Generate answers that will be used only for the latex version.
+    self.featured_answers = {
+      self.grammar_good.generate(),
+      self.grammar_bad.generate(),
+      self.grammar_good.generate(early_exit=True)
+    }
+    while len(self.featured_answers) < self.num_answer_options:
+      self.featured_answers.add(
+        self.rng.choice([
+          lambda: self.grammar_good.generate(),
+          lambda: self.grammar_bad.generate(),
+          lambda: self.grammar_good.generate(early_exit=True),
+        ])()
+      )
+  
+  
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_elements([
+      ContentAST.Paragraph([
+        ContentAST.OnlyHtml([
+          ContentAST.Text("Given the following grammar, which of the below strings are part of the language?")
+        ]),
+        ContentAST.OnlyLatex([
+          ContentAST.Text(
+            "Given the following grammar "
+            "please circle any provided strings that are part of the language (or indicate clearly if there are none), "
+            "and on each blank line provide generate a new, unique string that is part of the language."
+          )
+        ])
+      ])
+    ])
+    
+    body.add_element(
+      ContentAST.Code(self.grammar_good.get_grammar_string())
+    )
+    
+    # Add in some answers as latex-only options to be circled
+    body.add_element(
+      ContentAST.OnlyLatex([
+        ContentAST.Text(f"- `{str(answer)}`")
+        for answer in self.featured_answers
+      ])
+    )
+    
+    # For Latex-only, ask students to generate some more.
+    body.add_element(
+      ContentAST.OnlyLatex([
+        ContentAST.AnswerBlock([ContentAST.Answer(Answer.string(f"blank_line_{i}", f"blank_line_{i}"), label=f"blank_line_{i}") for i in range(self.num_answer_blanks)])
+      ])
+    )
+    
+    return body
+  
+  def get_explanation(self, *args, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Remember, for a string to be part of our language, we need to be able to derive it from our grammar.",
+        "Unfortunately, there isn't space here to demonstrate the derivation so please work through them on your own!"
+      ])
+    )
+    return explanation
+
+  def get_answers(self, *args, **kwargs) -> Tuple[Answer.AnswerKind, List[Dict[str,Any]]]:
+    
+    return Answer.AnswerKind.MULTIPLE_ANSWER, list(itertools.chain(*[a.get_for_canvas() for a in self.answers.values()]))