in2lambda 1.0.0__tar.gz → 1.0.1__tar.gz

{in2lambda-1.0.0 → in2lambda-1.0.1}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: in2lambda
-Version: 1.0.0
+Version: 1.0.1
 Summary: Converts content ready for import into Lambda Feedback
 License: MIT
+License-File: LICENSE
 Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
@@ -13,11 +14,13 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
 Requires-Dist: beartype (>=0.17.2,<0.18.0)
 Requires-Dist: panflute (>=2.3.1,<3.0.0)
-Requires-Dist: requests (<2.32.0)
+Requires-Dist: requests (<2.34.0)
 Requires-Dist: rich-click (>=1.7.4,<2.0.0)
 Project-URL: Bug Tracker, https://github.com/lambda-feedback/in2lambda/issues
 Project-URL: Documentation, https://lambda-feedback.github.io/in2lambda

in2lambda-1.0.1/in2lambda/api/part.py

@@ -0,0 +1,30 @@
+"""A part of a question."""
+
+from dataclasses import dataclass, field
+
+from in2lambda.api.response_area import ResponseArea
+
+
+@dataclass
+class Branch:
+    """A (titled) branch of a structured tutorial or worked solution, which may branch further."""
+
+    title: str
+    content: str
+    branches: list["Branch"] = field(default_factory=list)
+
+
+@dataclass
+class Part:
+    """A part of a question as represented on Lambda Feedback.
+
+    Markdown content for the question and supporting materials. Note that in ``tutorial`` and ``worked_solution`` fields, steps can by separated by a line with only ``---`` (or ``***``).
+    """
+
+    content: str = ""
+    response_areas: list[ResponseArea] = field(default_factory=list)
+    tutorial: str = ""
+    tutorial_branches: list[Branch] = field(default_factory=list)
+    answer: str = ""
+    worked_solution: str = ""
+    worked_solution_branches: list[Branch] = field(default_factory=list)

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/api/question.py

@@ -1,7 +1,7 @@
 """A full question with optional parts that's contained in a set."""
 
 from dataclasses import dataclass, field
-from typing import Union
+from typing import Optional, Union
 
 import panflute as pf
 
@@ -14,10 +14,12 @@ class Question:
 
     Each question has a title and is composed of a list of parts.
 
+    It also carries the settings Lambda Feedback keeps per question.
+
     Examples:
         >>> from in2lambda.api.question import Question
-        >>> Question(title="Some title", main_text="Some text")
-        Question(title='Some title', parts=[], images=[], main_text='Some text')
+        >>> Question(title="Some title", master_content="Some text")
+        Question(title='Some title', parts=[], images=[], master_content='Some text')
     """
 
     title: str = ""
@@ -25,10 +27,10 @@ class Question:
     parts: list[Part] = field(default_factory=list)
     images: list[str] = field(default_factory=list)
 
-    # Use getter/setter methods for main_text without exposing private attribute.
+    # Use getter/setter methods for master_content without exposing private attribute.
     # See https://stackoverflow.com/a/61480946
-    main_text: str = ""
-    _main_text: str = field(init=False, repr=False, default="")
+    master_content: str = ""
+    _master_content: str = field(init=False, repr=False, default="")
 
     _last_part: dict[str, int] = field(
         default_factory=lambda: {"solution": 0, "text": 0}, repr=False
@@ -36,8 +38,23 @@ class Question:
     """Keeps track of the last question part that contains a solution /
     text."""
 
+    # The settings below are left out of the repr, so that printing a question shows its
+    # content rather than nine lines of configuration.
+
+    # The skill level may be an int as well as a float, because Lambda Feedback writes
+    # its exports in JavaScript, which writes the levels 0.0 and 1.0 as 0 and 1.
+    skill: Optional[Union[int, float]] = field(default=None, repr=False)
+    guidance: Optional[str] = field(default=None, repr=False)
+    duration_lower_bound: Optional[int] = field(default=None, repr=False)
+    duration_upper_bound: Optional[int] = field(default=None, repr=False)
+    publish: bool = field(default=False, repr=False)
+    display_final_answer: bool = field(default=True, repr=False)
+    display_worked_solution: bool = field(default=True, repr=False)
+    display_structured_tutorial: bool = field(default=True, repr=False)
+    display_chatbot: bool = field(default=False, repr=False)
+
     @property
-    def main_text(self) -> str:
+    def master_content(self) -> str:
         r"""Main top-level question text.
 
         Setting the attribute multiple times appends to the current value with a newline.
@@ -46,21 +63,21 @@ class Question:
         Examples:
             >>> from in2lambda.api.question import Question
             >>> question = Question()
-            >>> question.main_text = "hello"
-            >>> question.main_text = "there"
-            >>> question.main_text
+            >>> question.master_content = "hello"
+            >>> question.master_content = "there"
+            >>> question.master_content
             'hello\nthere'
         """
-        return self._main_text
+        return self._master_content
 
-    @main_text.setter
-    def main_text(self, value: Union[pf.Element, str, property]) -> None:
+    @master_content.setter
+    def master_content(self, value: Union[pf.Element, str, property]) -> None:
         r"""Appends to the top-level main text, which starts off as an empty string.
 
         Args:
             value: A panflute element or string denoting what to append to the main text.
 
-        See example in main_text property.
+        See example in master_content property.
         """
         # Converts the inputted value into a string, stored in text_value
         match value:
@@ -69,13 +86,13 @@ class Question:
             case property():
                 # Use default value when no value set at initialisation.
                 # See https://stackoverflow.com/a/61480946
-                text_value = self.main_text
+                text_value = self.master_content
             case pf.Element():
                 text_value = pf.stringify(value, False)
 
-        if self._main_text:
-            self._main_text += "\n"
-        self._main_text += text_value
+        if self._master_content:
+            self._master_content += "\n"
+        self._master_content += text_value
 
     def add_solution(self, elem: Union[pf.Element, str]) -> None:
         """Adds a worked solution to all question parts without one, or inserts a new empty part with the solution if all parts already have a solution.
@@ -89,20 +106,20 @@ class Question:
             >>> question.add_part_text("part a")
             >>> question.add_solution("part a solution")
             >>> question
-            Question(title='', parts=[Part(text='part a', worked_solution='part a solution')], images=[], main_text='')
+            Question(title='', parts=[Part(content='part a', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part a solution', worked_solution_branches=[])], images=[], master_content='')
             >>> question.add_part_text("part b")
             >>> question.add_part_text("part c")
             >>> question.add_solution("Solution for b")
             >>> # Note that since c doesn't have a solution, it's set to b's solution
             >>> question
-            Question(title='', parts=[Part(text='part a', worked_solution='part a solution'), \
-Part(text='part b', worked_solution='Solution for b'), \
-Part(text='part c', worked_solution='Solution for b')], images=[], main_text='')
+            Question(title='', parts=[Part(content='part a', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part a solution', worked_solution_branches=[]), \
+Part(content='part b', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='Solution for b', worked_solution_branches=[]), \
+Part(content='part c', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='Solution for b', worked_solution_branches=[])], images=[], master_content='')
             >>> question.add_solution("We now have a solution for c!")
             >>> question
-            Question(title='', parts=[Part(text='part a', worked_solution='part a solution'), \
-Part(text='part b', worked_solution='Solution for b'), \
-Part(text='part c', worked_solution='We now have a solution for c!')], images=[], main_text='')
+            Question(title='', parts=[Part(content='part a', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part a solution', worked_solution_branches=[]), \
+Part(content='part b', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='Solution for b', worked_solution_branches=[]), \
+Part(content='part c', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='We now have a solution for c!', worked_solution_branches=[])], images=[], master_content='')
         """
         elem_text = elem if isinstance(elem, str) else pf.stringify(elem)
 
@@ -131,19 +148,19 @@ Part(text='part c', worked_solution='We now have a solution for c!')], images=[]
             >>> question.add_part_text("part a")
             >>> question.add_solution("part a solution")
             >>> question
-            Question(title='', parts=[Part(text='part a', worked_solution='part a solution')], images=[], main_text='')
+            Question(title='', parts=[Part(content='part a', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part a solution', worked_solution_branches=[])], images=[], master_content='')
             >>> # Supports adding the answer first.
             >>> question.add_solution("part b solution")
             >>> question.add_part_text("part b")
             >>> question
-            Question(title='', parts=[Part(text='part a', worked_solution='part a solution'), \
-Part(text='part b', worked_solution='part b solution')], images=[], main_text='')
+            Question(title='', parts=[Part(content='part a', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part a solution', worked_solution_branches=[]), \
+Part(content='part b', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='part b solution', worked_solution_branches=[])], images=[], master_content='')
         """
         elem_text = elem if isinstance(elem, str) else pf.stringify(elem)
 
         if len(self.parts) == self._last_part["text"]:
-            self.parts.append(Part(text=elem_text))
+            self.parts.append(Part(content=elem_text))
         else:
-            self.parts[self._last_part["text"]].text = elem_text
+            self.parts[self._last_part["text"]].content = elem_text
 
         self._last_part["text"] += 1

in2lambda-1.0.1/in2lambda/api/response_area.py

@@ -0,0 +1,317 @@
+"""An area for student responses that will receive automated feedback."""
+
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, ClassVar, Optional, Union
+
+
+def _new_id() -> str:
+    return str(uuid.uuid4())
+
+
+@dataclass
+class InputSymbol:
+    """Defines symbols and how to enter them into a response area.
+
+    Fields per symbol:
+    - ``symbol`` for display to users (markdown, typically dollar-delimited math latex)
+    - ``code`` for users to input (plan text, fed to the algorithm and also be rendered to users within backticks as `code`)
+    - ``aliases`` list of alternative code inputs, to be substituted by the `code` field when evaluating
+    - ``is_visible`` Boolean, whether to display input symbol info to users (in addition to always sending it to the evaluator to help parsing)
+    """
+
+    symbol: str
+    code: str
+    aliases: list[str] = field(default_factory=list)
+    is_visible: bool = True
+
+
+@dataclass
+class Test:
+    """Teacher author's assertions of how responses should be evaluated."""
+
+    # Its name would otherwise make pytest try to collect it wherever it is imported.
+    __test__ = False
+
+    payload: str
+    is_correct: bool
+    id: str = field(default_factory=_new_id)
+
+
+class Color(Enum):
+    """Acceptable colours for a feedback case."""
+
+    RED = "#ff5630"
+    AMBER = "#FFAB00"
+    GREEN = "#22C55E"
+    BLUE = "#0099c4"
+    GREY = "#C4CDD5"
+
+
+@dataclass
+class Case:
+    """A declared case for which bespoke feedback is prescribed."""
+
+    answer: str
+    feedback: str
+    is_correct: bool
+    params: Any = None
+    color: Optional[Color] = None
+    id: str = field(default_factory=_new_id)
+
+
+@dataclass(kw_only=True)
+class ResponseArea:
+    """Specifies the interaction when a student provides a response.
+
+    Multiple response areas per part are allowed; if so, order is implicit.
+    Use a subclass for each response type. ``grade_params`` are passed to the
+    evaluation function unedited.
+
+    Examples:
+        >>> from in2lambda.api.response_area import NumericUnits, Test
+        >>> area = NumericUnits(
+        ...     answer="30 N",
+        ...     grade_params={"rtol": 0.05},
+        ...     pre_text="$F=$",
+        ...     tests=[Test("30 N", True)],
+        ... )
+        >>> area.response_type, area.evaluation_function
+        ('NUMERIC_UNITS', 'compareExpressions')
+    """
+
+    response_type: ClassVar[str]
+    answer: Any = None
+    evaluation_function: str
+    grade_params: Optional[dict[str, Any]] = None
+    pre_text: str = ""
+    post_text: str = ""
+    content_after: str = ""
+    """Markdown shown after the box, before the next one."""
+    check_button_text: str = ""
+    """Replaces the label of the check button; left out of the JSON when empty."""
+    input_symbols: list[InputSymbol] = field(default_factory=list)
+    display_input_symbols: bool = False
+    live_preview: bool = False
+    include_in_pdf: bool = False
+    save_allowed: bool = False
+    separate_feedback: bool = True
+    common_feedback_color: str = "#C4CDD5"
+    correct_feedback_color: str = "#22C55E"
+    correct_feedback_prefix: str = "Correct"
+    incorrect_feedback_color: str = "#ff5630"
+    incorrect_feedback_prefix: str = "Incorrect"
+    tests: list[Test] = field(default_factory=list)
+    cases: list[Case] = field(default_factory=list)
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        """The response type's settings, as Lambda Feedback writes them."""
+        return None
+
+    def _grade_params(self) -> Optional[dict[str, Any]]:
+        """The parameters sent to the evaluation function."""
+        return self.grade_params
+
+
+@dataclass(kw_only=True)
+class _Maths(ResponseArea):
+    answer: str = ""
+    allow_handwrite: bool = True
+    allow_photo: bool = True
+    enable_refinement: bool = True
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "allowHandwrite": self.allow_handwrite,
+            "allowPhoto": self.allow_photo,
+            "enableRefinement": self.enable_refinement,
+        }
+
+
+@dataclass(kw_only=True)
+class MathSingleLine(_Maths):
+    """A single symbolic expression."""
+
+    response_type: ClassVar[str] = "MATH_SINGLE_LINE"
+    evaluation_function: str = "compareExpressions"
+
+
+@dataclass(kw_only=True)
+class MathMultiLines(_Maths):
+    """Multiple lines of mathematical work."""
+
+    response_type: ClassVar[str] = "MATH_MULTI_LINES"
+
+
+@dataclass(kw_only=True)
+class Number(ResponseArea):
+    """A number."""
+
+    response_type: ClassVar[str] = "NUMBER"
+    answer: Optional[Union[int, float]] = None
+    evaluation_function: str = "isSimilar"
+
+
+@dataclass(kw_only=True)
+class NumericUnits(ResponseArea):
+    """A number with units, e.g. ``30 N``."""
+
+    response_type: ClassVar[str] = "NUMERIC_UNITS"
+    answer: str = ""
+    evaluation_function: str = "compareExpressions"
+
+    def _grade_params(self) -> Optional[dict[str, Any]]:
+        # compareExpressions compares units only when told to.
+        return {"physical_quantity": True, **(self.grade_params or {})}
+
+
+@dataclass(kw_only=True)
+class Text(ResponseArea):
+    """A short piece of text."""
+
+    response_type: ClassVar[str] = "TEXT"
+    answer: str = ""
+
+
+@dataclass(kw_only=True)
+class Boolean(ResponseArea):
+    """True or false."""
+
+    response_type: ClassVar[str] = "BOOLEAN"
+    answer: bool = False
+    evaluation_function: str = "isExactEqual"
+
+
+@dataclass(kw_only=True)
+class MultipleChoice(ResponseArea):
+    """A choice among ``options``; ``answer`` marks each option correct or not."""
+
+    response_type: ClassVar[str] = "MULTIPLE_CHOICE"
+    answer: list[bool] = field(default_factory=list)
+    evaluation_function: str = "arrayEqual"
+    options: list[str] = field(default_factory=list)
+    single: bool = True
+    randomise: bool = False
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "options": self.options,
+            "randomise": self.randomise,
+            "single": self.single,
+        }
+
+
+@dataclass(kw_only=True)
+class Table(ResponseArea):
+    """A grid of cells, one row per row name and one column per column name."""
+
+    response_type: ClassVar[str] = "TABLE"
+    answer: list[list[str]] = field(default_factory=list)
+    evaluation_function: str = "arraySymbolicEqual"
+    row_names: list[str] = field(default_factory=list)
+    col_names: list[str] = field(default_factory=list)
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "rows": len(self.row_names),
+            "cols": len(self.col_names),
+            "rowNames": self.row_names,
+            "colNames": self.col_names,
+        }
+
+
+@dataclass(kw_only=True)
+class Matrix(ResponseArea):
+    """A table, with parentheses displayed around it, with the shape of ``answer``."""
+
+    response_type: ClassVar[str] = "MATRIX"
+    answer: list[list[str]] = field(default_factory=list)
+    evaluation_function: str = "arraySymbolicEqual"
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "rows": len(self.answer),
+            "cols": len(self.answer[0]) if self.answer else 0,
+        }
+
+
+@dataclass(kw_only=True)
+class Code(ResponseArea):
+    """A monaco code editor."""
+
+    response_type: ClassVar[str] = "CODE"
+    answer: str = ""
+    evaluation_function: str = "evaluatePython"
+    language: str = "python"
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {"language": self.language}
+
+
+@dataclass(kw_only=True)
+class Essay(ResponseArea):
+    """Large text box."""
+
+    response_type: ClassVar[str] = "ESSAY"
+    answer: Union[str, dict[str, str]] = ""
+    allow_draw: bool = False
+    allow_scan: bool = False
+    repeat_for_subjects: bool = False
+    allow_empty_submission: bool = False
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "allowDraw": self.allow_draw,
+            "allowScan": self.allow_scan,
+            "repeatForSubjects": self.repeat_for_subjects,
+            "allowEmptySubmission": self.allow_empty_submission,
+        }
+
+
+@dataclass(kw_only=True)
+class Likert(ResponseArea):
+    """A multiple choice with Likert scales."""
+
+    response_type: ClassVar[str] = "LIKERT"
+    answer: Union[
+        list[Optional[Union[int, float]]],
+        dict[str, list[Optional[Union[int, float]]]],
+        None,
+    ] = None
+    statements: list[str] = field(default_factory=list)
+    options: Optional[list[str]] = None
+    repeat_for_subjects: bool = False
+    allow_empty_submission: bool = False
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        config: dict[str, Any] = {
+            "statements": self.statements,
+            "repeatForSubjects": self.repeat_for_subjects,
+            "allowEmptySubmission": self.allow_empty_submission,
+        }
+        if self.options is not None:
+            config["options"] = self.options
+        return config
+
+
+@dataclass(kw_only=True)
+class Images(ResponseArea):
+    """Upload images."""
+
+    response_type: ClassVar[str] = "IMAGES"
+    max_images: int = 3
+    allowed_types: list[str] = field(
+        default_factory=lambda: ["image/jpg", "image/jpeg", "image/png"]
+    )
+    max_size_mb: int = 10
+    resize_max_side: int = 0
+    """The longest side images are resized to; 0 leaves them as they are."""
+
+    def _config(self) -> Optional[dict[str, Any]]:
+        return {
+            "maxImages": self.max_images,
+            "allowedTypes": self.allowed_types,
+            "maxSizeMb": self.max_size_mb,
+            "resizeMaxSide": self.resize_max_side,
+        }

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/api/set.py

@@ -1,7 +1,7 @@
 """Represents a list of questions."""
 
 from dataclasses import dataclass, field
-from typing import Union
+from typing import Optional, Union
 
 import panflute as pf
 
@@ -11,7 +11,11 @@ from in2lambda.api.visibility_status import VisibilityController, VisibilityStat
 
 @dataclass
 class Set:
-    """Represents a list of questions."""
+    """Represents a list of questions.
+
+    A collection of questions. Contains set-level parameters including visibility, with
+    release dates (ISO 8601 time, omitted if unset), and survey status.
+    """
 
     _name: str = field(default="set")
     _description: str = field(default="")
@@ -28,6 +32,13 @@ class Set:
     _structuredTutorialVisibility: VisibilityController = field(
         default_factory=lambda: VisibilityController(VisibilityStatus.OPEN)
     )
+    _chatbotVisibility: VisibilityController = field(
+        default_factory=lambda: VisibilityController(VisibilityStatus.HIDE)
+    )
+    is_survey: bool = False
+    released_at: Optional[str] = None
+    hidden_at: Optional[str] = None
+    manually_hidden: bool = True
 
     questions: list[Question] = field(default_factory=list)
     _current_question_index = -1
@@ -45,11 +56,11 @@ class Set:
         Examples:
             >>> from in2lambda.api.set import Set
             >>> Set().current_question
-            Question(title='INVALID', parts=[], images=[], main_text='')
+            Question(title='INVALID', parts=[], images=[], master_content='')
             >>> s = Set()
             >>> s.add_question()
             >>> s.current_question
-            Question(title='', parts=[], images=[], main_text='')
+            Question(title='', parts=[], images=[], master_content='')
         """
         return (
             self.questions[self._current_question_index]
@@ -58,14 +69,14 @@ class Set:
         )
 
     def add_question(
-        self, title: str = "", main_text: Union[pf.Element, str] = pf.Str("")
+        self, title: str = "", master_content: Union[pf.Element, str] = pf.Str("")
     ) -> None:
         """Inserts a new question into the set.
 
         Args:
             title: An optional string for the title of the question. If no title
                 is provided, the question title auto-increments i.e. Question 1, 2, etc.
-            main_text: An optional string or panflute element for the main question text.
+            master_content: An optional string or panflute element for the main question text.
 
         Examples:
             >>> from in2lambda.api.set import Set
@@ -73,13 +84,13 @@ class Set:
             >>> s = Set()
             >>> s.add_question("Some title", pf.Para(pf.Str("hello"), pf.Space, pf.Str("there")))
             >>> s.questions
-            [Question(title='Some title', parts=[], images=[], main_text='hello there')]
-            >>> s.add_question(main_text="Normal string text")
-            >>> s.questions[1].main_text
+            [Question(title='Some title', parts=[], images=[], master_content='hello there')]
+            >>> s.add_question(master_content="Normal string text")
+            >>> s.questions[1].master_content
             'Normal string text'
         """
         question = Question(title=title)
-        question.main_text = main_text
+        question.master_content = master_content
         self.questions.append(question)
 
     def increment_current_question(self) -> None:
@@ -102,8 +113,8 @@ class Set:
             >>> s.increment_current_question()
             >>> s.current_question.add_solution("Question 2 answer")
             >>> s.questions
-            [Question(title='Question 1', parts=[Part(text='', worked_solution='Question 1 answer')], images=[], main_text=''),\
- Question(title='Question 2', parts=[Part(text='', worked_solution='Question 2 answer')], images=[], main_text='')]
+            [Question(title='Question 1', parts=[Part(content='', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='Question 1 answer', worked_solution_branches=[])], images=[], master_content=''),\
+ Question(title='Question 2', parts=[Part(content='', response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='Question 2 answer', worked_solution_branches=[])], images=[], master_content='')]
         """
         self._current_question_index += 1
 
@@ -180,6 +191,11 @@ class Set:
             f"_finalAnswerVisibility={str(self._finalAnswerVisibility)!r}, "
             f"_workedSolutionVisibility={str(self._workedSolutionVisibility)!r}, "
             f"_structuredTutorialVisibility={str(self._structuredTutorialVisibility)!r}, "
+            f"_chatbotVisibility={str(self._chatbotVisibility)!r}, "
+            f"is_survey={self.is_survey!r}, "
+            f"released_at={self.released_at!r}, "
+            f"hidden_at={self.hidden_at!r}, "
+            f"manually_hidden={self.manually_hidden!r}, "
             f"questions={self.questions!r}"
             f")"
         )

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/api/visibility_status.py

@@ -2,6 +2,7 @@
 
 from enum import Enum
 
+
 class VisibilityStatus(Enum):
     """Enum representing the visibility status of a question or set."""
 

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/filters/PartPartSolSol/filter.py

@@ -46,7 +46,7 @@ def pandoc_filter(
 
     # Solutions are in a Div
     if isinstance(elem, pf.Div):
-        set.add_question(main_text="\n".join(pandoc_filter.question))
+        set.add_question(master_content="\n".join(pandoc_filter.question))
         if hasattr(pandoc_filter, "parts"):
             for part in pandoc_filter.parts:
                 set.current_question.add_part_text(part)

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/filters/PartSolPartSol/filter.py

@@ -54,7 +54,7 @@ def pandoc_filter(
     if isinstance(elem, pf.Div):
         pandoc_filter.solutions.append(pf.stringify(elem))
         if pandoc_filter.question:
-            set.add_question(main_text="\n".join(pandoc_filter.question))
+            set.add_question(master_content="\n".join(pandoc_filter.question))
             set.current_question.add_solution(pf.stringify(elem))
             set.current_question._last_part["solution"] -= 1
         pandoc_filter.question = []

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/filters/PartsOneSol/filter.py

@@ -42,7 +42,7 @@ def pandoc_filter(
                 isinstance(elem.prev, pf.Header)
                 and pf.stringify(elem.prev) != "Solution"
             ):
-                set.add_question(main_text=elem)
+                set.add_question(master_content=elem)
 
         # Parts are denoted via ordered lists
         case pf.OrderedList:

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/filters/PartsSepSol/filter.py

@@ -67,7 +67,7 @@ def pandoc_filter(
                 set.current_question.add_solution(spaced_blurb)
             # Add the main question text as the Lambda Feedback blurb
             elif not parsing_answers:
-                set.add_question(main_text=spaced_blurb)
+                set.add_question(master_content=spaced_blurb)
 
             # Add each part solution/text
             # For the solution, prepend any top level answer text to each part answer

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/filters/markdown.py

@@ -119,7 +119,7 @@ def filter(
     func: Callable[
         [pf.Element, pf.elements.Doc, Set, bool],
         Optional[pf.Str],
-    ]
+    ],
 ) -> Callable[
     [pf.Element, pf.elements.Doc, Set, str, bool],
     Optional[pf.Str],

in2lambda-1.0.1/in2lambda/json_convert/json_convert.py

@@ -0,0 +1,259 @@
+"""Converts questions from a Python set object into Lambda Feedback JSON."""
+
+import json
+import os
+import re
+import shutil
+import zipfile
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from in2lambda.api.part import Branch, Part
+from in2lambda.api.response_area import Case, ResponseArea
+from in2lambda.api.set import Set
+
+MINIMAL_QUESTION_TEMPLATE = "minimal_template_question.json"
+MINIMAL_SET_TEMPLATE = "minimal_template_set.json"
+
+
+def _zip_sorted_folder(folder_path, zip_path):
+    """Zips the contents of a folder, preserving the directory structure.
+
+    Args:
+        folder_path: The path to the folder to zip.
+        zip_path: The path where the zip file will be created.
+    """
+    with zipfile.ZipFile(zip_path, "w") as zf:
+        for root, dirs, files in os.walk(folder_path):
+            # Sort files for deterministic, alphabetical order
+            for file in sorted(files):
+                abs_path = os.path.join(root, file)
+                rel_path = os.path.relpath(abs_path, folder_path)
+                zf.write(abs_path, arcname=rel_path)
+
+
+def _case_to_json(case: Case) -> dict[str, Any]:
+    output = {
+        "id": case.id,
+        "answer": case.answer,
+        "feedback": case.feedback,
+        "isCorrect": case.is_correct,
+        "params": case.params,
+    }
+    if case.color is not None:
+        output["color"] = case.color.value
+    return output
+
+
+def _response_area_to_json(area: ResponseArea, order: int) -> dict[str, Any]:
+    output = {
+        "orderNumber": order,
+        "contentAfter": area.content_after,
+        "preResponseText": area.pre_text,
+        "postResponseText": area.post_text,
+        "inputSymbols": [
+            {
+                "symbol": symbol.symbol,
+                "code": symbol.code,
+                "aliases": symbol.aliases,
+                "isVisible": symbol.is_visible,
+            }
+            for symbol in area.input_symbols
+        ],
+        "displayInputSymbols": area.display_input_symbols,
+        "includeInPdf": area.include_in_pdf,
+        "saveAllowed": area.save_allowed,
+        "evaluationFunctionName": area.evaluation_function,
+        "livePreview": area.live_preview,
+        "gradeParams": area._grade_params(),
+        "separateFeedback": area.separate_feedback,
+        "commonFeedbackColor": area.common_feedback_color,
+        "correctFeedbackColor": area.correct_feedback_color,
+        "correctFeedbackPrefix": area.correct_feedback_prefix,
+        "incorrectFeedbackColor": area.incorrect_feedback_color,
+        "incorrectFeedbackPrefix": area.incorrect_feedback_prefix,
+        "tests": [
+            {
+                "id": test.id,
+                "payload": test.payload,
+                "expectedResponse": {"isCorrect": test.is_correct},
+            }
+            for test in area.tests
+        ],
+        "cases": [_case_to_json(case) for case in area.cases],
+        "response": {
+            "responseInput": {
+                "responseType": area.response_type,
+                "answer": area.answer,
+                "config": area._config(),
+            }
+        },
+    }
+    if area.check_button_text:
+        output["checkButtonText"] = area.check_button_text
+    return output
+
+
+def _branch_to_json(branch: Branch) -> dict[str, Any]:
+    return {
+        "title": branch.title,
+        "content": branch.content,
+        "children": [_branch_to_json(child) for child in branch.branches],
+    }
+
+
+def _part_to_json(part: Part, order: int) -> dict[str, Any]:
+    output = {
+        "orderNumber": order,
+        "content": part.content,
+        "answerContent": part.answer,
+        "responseAreas": [
+            _response_area_to_json(area, j)
+            for j, area in enumerate(part.response_areas)
+        ],
+    }
+    # Lambda Feedback leaves each key out of a part that has none.
+    for key, content, branches in (
+        ("tutorial", part.tutorial, part.tutorial_branches),
+        ("workedSolution", part.worked_solution, part.worked_solution_branches),
+    ):
+        if content or branches:
+            output[key] = {
+                "content": content,
+                "children": [_branch_to_json(branch) for branch in branches],
+            }
+    return output
+
+
+def converter(
+    question_template: dict[str, Any],
+    set_template: dict[str, Any],
+    SetQuestions: Set,
+    output_dir: str,
+) -> None:
+    """Turns a set of question objects into Lambda Feedback JSON.
+
+    Args:
+        question_template: The loaded JSON from the minimal question template (it needs to be in sync).
+        set_template: The loaded JSON from the minimal set template (it needs to be in sync).
+        SetQuestions: A Set object containing questions.
+        output_dir: The absolute path for where to produced the final JSON/zip files.
+    """
+    ListQuestions = SetQuestions.questions
+    set_name = SetQuestions._name
+    set_description = SetQuestions._description
+
+    # create directory to put the questions
+    os.makedirs(output_dir, exist_ok=True)
+    output_question = os.path.join(output_dir, set_name)
+    os.makedirs(output_question, exist_ok=True)
+
+    set_template["name"] = set_name
+    set_template["description"] = set_description
+    set_template["finalAnswerVisibility"] = str(
+        SetQuestions._finalAnswerVisibility.status
+    )
+    set_template["workedSolutionVisibility"] = str(
+        SetQuestions._workedSolutionVisibility.status
+    )
+    set_template["structuredTutorialVisibility"] = str(
+        SetQuestions._structuredTutorialVisibility.status
+    )
+    set_template["chatbotVisibility"] = str(SetQuestions._chatbotVisibility.status)
+    set_template["isSurvey"] = SetQuestions.is_survey
+    set_template["manuallyHidden"] = SetQuestions.manually_hidden
+    for key, value in {
+        "releasedAt": SetQuestions.released_at,
+        "hiddenAt": SetQuestions.hidden_at,
+    }.items():
+        if value is not None:
+            set_template[key] = value
+    # create the set file
+    with open(f"{output_question}/set_{set_name}.json", "w") as file:
+        json.dump(set_template, file)
+
+    for i in range(len(ListQuestions)):
+        output = deepcopy(question_template)
+
+        output["orderNumber"] = i  # order number starts at 0
+        # add title to the question file
+        if ListQuestions[i].title != "":
+            output["title"] = ListQuestions[i].title
+        else:
+            output["title"] = "Question " + str(i + 1)
+
+        # add main text to the question file
+        output["masterContent"] = ListQuestions[i].master_content
+
+        question = ListQuestions[i]
+        output["publish"] = question.publish
+        output["displayFinalAnswer"] = question.display_final_answer
+        output["displayWorkedSolution"] = question.display_worked_solution
+        output["displayStructuredTutorial"] = question.display_structured_tutorial
+        output["displayChatbot"] = question.display_chatbot
+        # An unset optional setting is left out of the JSON, so that in2lambda writes no
+        # value the author did not choose.
+        for key, value in {
+            "skill": question.skill,
+            "guidance": question.guidance,
+            "durationLowerBound": question.duration_lower_bound,
+            "durationUpperBound": question.duration_upper_bound,
+        }.items():
+            if value is not None:
+                output[key] = value
+
+        if question.parts:
+            output["parts"] = [
+                _part_to_json(part, j) for j, part in enumerate(question.parts)
+            ]
+
+        # Output file
+        filename = (
+            "question_"
+            + str(i).zfill(3)
+            + "_"
+            + re.sub(r"[^\w\-_.]", "_", output["title"].strip())
+        )
+
+        # write questions into directory
+        with open(f"{output_question}/{filename}.json", "w") as file:
+            json.dump(output, file)
+
+        # write image into directory
+        for k in range(len(ListQuestions[i].images)):
+            image_path = os.path.abspath(
+                ListQuestions[i].images[k]
+            )  # converts computer path into python path
+            # If images exist, create a media directory
+            output_image = os.path.join(output_question, "media")
+            os.makedirs(output_image, exist_ok=True)
+            shutil.copy(image_path, output_image)  # copies image into the directory
+
+    # output zip file in destination folder
+    _zip_sorted_folder(output_question, output_question + ".zip")
+
+
+def main(set_questions: Set, output_dir: str) -> None:
+    """Preliminary defensive programming before calling the main converter function.
+
+    This ultimately then produces the Lambda Feedback JSON/ZIP files.
+
+    Args:
+        set_questions: A Set object containing questions.
+        output_dir: Where to output the final Lambda Feedback JSON/ZIP files.
+    """
+    # Use path so minimal template can be found regardless of where the user is running python from.
+    with open(Path(__file__).with_name(MINIMAL_QUESTION_TEMPLATE), "r") as file:
+        question_template = json.load(file)
+
+    with open(Path(__file__).with_name(MINIMAL_SET_TEMPLATE), "r") as file:
+        set_template = json.load(file)
+
+    # check if directory exists in file
+    if os.path.isdir(output_dir):
+        try:
+            shutil.rmtree(output_dir)
+        except OSError as e:
+            print("Error: %s : %s" % (output_dir, e.strerror))
+    converter(question_template, set_template, set_questions, output_dir)

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/json_convert/minimal_template_question.json

@@ -14,7 +14,6 @@
       "answerContent": "",
       "responseAreas": [],
       "workedSolution": {
-        "title": "",
         "content": "Part worked solution here",
         "children": []
       }

{in2lambda-1.0.0 → in2lambda-1.0.1}/in2lambda/main.py

@@ -100,9 +100,9 @@ def runner(
         >>> from in2lambda.main import runner
         >>> # Retrieve an example TeX file and run the given filter.
         >>> runner(f"{os.path.dirname(in2lambda.__file__)}/filters/PartsSepSol/example.tex", "PartsSepSol") # doctest: +ELLIPSIS
-        Set(_name='set', _description='', _finalAnswerVisibility='OPEN_WITH_WARNINGS', _workedSolutionVisibility='OPEN_WITH_WARNINGS', _structuredTutorialVisibility='OPEN', questions=[Question(title='', parts=[Part(text=..., worked_solution=''), ...], images=[], main_text='This is a sample question\n\n'), ...])
+        Set(_name='set', _description='', _finalAnswerVisibility='OPEN_WITH_WARNINGS', _workedSolutionVisibility='OPEN_WITH_WARNINGS', _structuredTutorialVisibility='OPEN', _chatbotVisibility='HIDE', is_survey=False, released_at=None, hidden_at=None, manually_hidden=True, questions=[Question(title='', parts=[Part(content=..., response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='', worked_solution_branches=[]), ...], images=[], master_content='This is a sample question\n\n'), ...])
         >>> runner(f"{os.path.dirname(in2lambda.__file__)}/filters/PartsOneSol/example.tex", "PartsOneSol") # doctest: +ELLIPSIS
-        Set(_name='set', _description='', _finalAnswerVisibility='OPEN_WITH_WARNINGS', _workedSolutionVisibility='OPEN_WITH_WARNINGS', _structuredTutorialVisibility='OPEN', questions=[Question(title='', parts=[Part(text=..., worked_solution=''), ...], images=[], main_text='Here is some preliminary question information that might be useful.'), ...])
+        Set(_name='set', _description='', _finalAnswerVisibility='OPEN_WITH_WARNINGS', _workedSolutionVisibility='OPEN_WITH_WARNINGS', _structuredTutorialVisibility='OPEN', _chatbotVisibility='HIDE', is_survey=False, released_at=None, hidden_at=None, manually_hidden=True, questions=[Question(title='', parts=[Part(content=..., response_areas=[], tutorial='', tutorial_branches=[], answer='', worked_solution='', worked_solution_branches=[]), ...], images=[], master_content='Here is some preliminary question information that might be useful.'), ...])
     """
     # The list of questions for Lambda Feedback as a Python API.
     set_obj = Set()

{in2lambda-1.0.0 → in2lambda-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "in2lambda"
-version = "1.0.0"
+version = "1.0.1"
 description = "Converts content ready for import into Lambda Feedback"
 authors = []
 license = "MIT"
@@ -26,17 +26,17 @@ python = "^3.10"
 panflute = "^2.3.1"
 rich-click = "^1.7.4"
 beartype = "^0.17.2"
-requests = "<2.32.0"
+requests = "<2.34.0"
 
 [tool.poetry.scripts]
 in2lambda = "in2lambda.main:cli"
 
 [tool.poetry.group.dev.dependencies]
-black = "^24.3.0"
+black = ">=24.3,<27.0"
 isort = "^5.13.2"
 pydocstyle = "^6.3.0"
 mypy = "^1.9.0"
-pytest = "^8.1.1"
+pytest = ">=8.1.1,<10.0.0"
 pytest-cov = "^4.1.0"
 pytest-sugar = "^1.0.0"
 pre-commit = "^3.6.2"
@@ -60,6 +60,11 @@ ignore_missing_imports = true
 [tool.isort]
 profile = "black"
 
+[tool.pytest.ini_options]
+# Collect both the unit tests in tests/ and the doctests embedded in the package.
+testpaths = ["tests", "in2lambda"]
+addopts = "--doctest-modules"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

in2lambda-1.0.0/in2lambda/api/part.py

@@ -1,11 +0,0 @@
-"""A part of a question."""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class Part:
-    """A part of a question as represented on Lambda Feedback."""
-
-    text: str = ""
-    worked_solution: str = ""

in2lambda-1.0.0/in2lambda/json_convert/json_convert.py

@@ -1,144 +0,0 @@
-"""Converts questions from a Python set object into Lambda Feedback JSON."""
-
-import json
-import os
-import re
-import shutil
-import zipfile
-from copy import deepcopy
-from pathlib import Path
-from typing import Any
-
-from in2lambda.api.set import Set
-
-MINIMAL_QUESTION_TEMPLATE = "minimal_template_question.json"
-MINIMAL_SET_TEMPLATE = "minimal_template_set.json"
-
-
-def _zip_sorted_folder(folder_path, zip_path):
-    """Zips the contents of a folder, preserving the directory structure.
-
-    Args:
-        folder_path: The path to the folder to zip.
-        zip_path: The path where the zip file will be created.
-    """
-    with zipfile.ZipFile(zip_path, "w") as zf:
-        for root, dirs, files in os.walk(folder_path):
-            # Sort files for deterministic, alphabetical order
-            for file in sorted(files):
-                abs_path = os.path.join(root, file)
-                rel_path = os.path.relpath(abs_path, folder_path)
-                zf.write(abs_path, arcname=rel_path)
-
-
-def converter(
-    question_template: dict[str, Any],
-    set_template: dict[str, Any],
-    SetQuestions: Set,
-    output_dir: str,
-) -> None:
-    """Turns a set of question objects into Lambda Feedback JSON.
-
-    Args:
-        question_template: The loaded JSON from the minimal question template (it needs to be in sync).
-        set_template: The loaded JSON from the minimal set template (it needs to be in sync).
-        SetQuestions: A Set object containing questions.
-        output_dir: The absolute path for where to produced the final JSON/zip files.
-    """
-    ListQuestions = SetQuestions.questions
-    set_name = SetQuestions._name
-    set_description = SetQuestions._description
-
-    # create directory to put the questions
-    os.makedirs(output_dir, exist_ok=True)
-    output_question = os.path.join(output_dir, set_name)
-    os.makedirs(output_question, exist_ok=True)
-
-    set_template["name"] = set_name
-    set_template["description"] = set_description
-    set_template["finalAnswerVisibility"] = str(
-        SetQuestions._finalAnswerVisibility.status
-    )
-    set_template["workedSolutionVisibility"] = str(
-        SetQuestions._workedSolutionVisibility.status
-    )
-    set_template["structuredTutorialVisibility"] = str(
-        SetQuestions._structuredTutorialVisibility.status
-    )
-    # create the set file
-    with open(f"{output_question}/set_{set_name}.json", "w") as file:
-        json.dump(set_template, file)
-
-    for i in range(len(ListQuestions)):
-        output = deepcopy(question_template)
-
-        output["orderNumber"] = i  # order number starts at 0
-        # add title to the question file
-        if ListQuestions[i].title != "":
-            output["title"] = ListQuestions[i].title
-        else:
-            output["title"] = "Question " + str(i + 1)
-
-        # add main text to the question file
-        output["masterContent"] = ListQuestions[i].main_text
-
-        # add parts to the question file
-        if ListQuestions[i].parts:
-            output["parts"][0]["content"] = ListQuestions[i].parts[0].text
-            output["parts"][0]["workedSolution"]["content"] = (
-                ListQuestions[i].parts[0].worked_solution
-            )
-            for j in range(1, len(ListQuestions[i].parts)):
-                output["parts"].append(deepcopy(question_template["parts"][0]))
-                output["parts"][j]["content"] = ListQuestions[i].parts[j].text
-                output["parts"][j]["orderNumber"] = j
-                output["parts"][j]["workedSolution"]["content"] = (
-                    ListQuestions[i].parts[j].worked_solution
-                )
-
-        # Output file
-        filename = (
-            "question_" + str(i).zfill(3) + "_" + re.sub(r'[^\w\-_.]', '_', output['title'].strip())
-        )
-
-        # write questions into directory
-        with open(f"{output_question}/{filename}.json", "w") as file:
-            json.dump(output, file)
-
-        # write image into directory
-        for k in range(len(ListQuestions[i].images)):
-            image_path = os.path.abspath(
-                ListQuestions[i].images[k]
-            )  # converts computer path into python path
-            # If images exist, create a media directory
-            output_image = os.path.join(output_question, "media")
-            os.makedirs(output_image, exist_ok=True)
-            shutil.copy(image_path, output_image)  # copies image into the directory
-
-    # output zip file in destination folder
-    _zip_sorted_folder(output_question, output_question + ".zip")
-
-
-def main(set_questions: Set, output_dir: str) -> None:
-    """Preliminary defensive programming before calling the main converter function.
-
-    This ultimately then produces the Lambda Feedback JSON/ZIP files.
-
-    Args:
-        set_questions: A Set object containing questions.
-        output_dir: Where to output the final Lambda Feedback JSON/ZIP files.
-    """
-    # Use path so minimal template can be found regardless of where the user is running python from.
-    with open(Path(__file__).with_name(MINIMAL_QUESTION_TEMPLATE), "r") as file:
-        question_template = json.load(file)
-
-    with open(Path(__file__).with_name(MINIMAL_SET_TEMPLATE), "r") as file:
-        set_template = json.load(file)
-
-    # check if directory exists in file
-    if os.path.isdir(output_dir):
-        try:
-            shutil.rmtree(output_dir)
-        except OSError as e:
-            print("Error: %s : %s" % (output_dir, e.strerror))
-    converter(question_template, set_template, set_questions, output_dir)