in2lambda 0.3.1__tar.gz → 0.3.2__tar.gz

{in2lambda-0.3.1 → in2lambda-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: in2lambda
-Version: 0.3.1
+Version: 0.3.2
 Summary: Converts content ready for import into Lambda Feedback
 Home-page: https://lambda-feedback.github.io/in2lambda
 License: MIT
@@ -12,11 +12,12 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Typing :: Typed
-Requires-Dist: beartype (>=0.16.4,<0.17.0)
-Requires-Dist: panflute (>=2.3.0,<3.0.0)
-Requires-Dist: rich-click (>=1.7.2,<2.0.0)
+Requires-Dist: beartype (>=0.17.2,<0.18.0)
+Requires-Dist: panflute (>=2.3.1,<3.0.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
 Project-URL: Repository, https://github.com/lambda-feedback/in2lambda

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/api/module.py

@@ -6,6 +6,7 @@ from typing import Union
 import panflute as pf
 
 from in2lambda.api.question import Question
+from in2lambda.json_convert import json_convert
 
 
 @dataclass
@@ -28,11 +29,11 @@ class Module:
         Examples:
             >>> from in2lambda.api.module import Module
             >>> Module().current_question
-            Question(title='INVALID', parts=[], images=[], _main_text='')
+            Question(title='INVALID', parts=[], images=[], main_text='')
             >>> module = Module()
             >>> module.add_question()
             >>> module.current_question
-            Question(title='', parts=[], images=[], _main_text='')
+            Question(title='', parts=[], images=[], main_text='')
         """
         return (
             self.questions[self._current_question_index]
@@ -56,7 +57,7 @@ class Module:
             >>> module = Module()
             >>> module.add_question("Some title", pf.Para(pf.Str("hello"), pf.Space, pf.Str("there")))
             >>> module
-            Module(questions=[Question(title='Some title', parts=[], images=[], _main_text='hello there')])
+            Module(questions=[Question(title='Some title', parts=[], images=[], main_text='hello there')])
             >>> module.add_question(main_text="Normal string text")
             >>> module.questions[1].main_text
             'Normal string text'
@@ -85,7 +86,37 @@ class Module:
             >>> module.increment_current_question()
             >>> module.current_question.add_solution("Question 2 answer")
             >>> module.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(text='', worked_solution='Question 1 answer')], images=[], main_text=''),\
+ Question(title='Question 2', parts=[Part(text='', worked_solution='Question 2 answer')], images=[], main_text='')]
         """
         self._current_question_index += 1
+
+    def to_json(self, output_dir: str) -> None:
+        """Turns this module into Lambda Feedback JSON/ZIP files.
+
+        WARNING: This will overwrite any existing files in the directory.
+
+        Args:
+            output_dir: Where to output the final Lambda Feedback JSON/ZIP files.
+
+        Examples:
+            >>> import tempfile
+            >>> import os
+            >>> import json
+            >>> # Create a module with two questions
+            >>> module = Module()
+            >>> module.add_question("Question 1")
+            >>> module.add_question("Question 2")
+            >>> with tempfile.TemporaryDirectory() as temp_dir:
+            ...     # Write the JSON files to the temporary directory
+            ...     module.to_json(temp_dir)
+            ...     # Check the contents of the directory
+            ...     sorted(os.listdir(temp_dir))
+            ...     # Check the title of the first question
+            ...     with open(f"{temp_dir}/question_1/question_1.json") as file:
+            ...         print(f"Question 1's title: {json.load(file)['title']}")
+            ['question_1', 'question_1.zip', 'question_2', 'question_2.zip']
+            Question 1's title: Question 1
+
+        """
+        json_convert.main(self.questions, output_dir)

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/api/question.py

@@ -16,8 +16,8 @@ class 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", main_text="Some text")
+        Question(title='Some title', parts=[], images=[], main_text='Some text')
     """
 
     title: str = ""
@@ -25,7 +25,11 @@ class Question:
     parts: list[Part] = field(default_factory=list)
     images: list[str] = field(default_factory=list)
 
-    _main_text: str = ""
+    # Use getter/setter methods for main_text without exposing private attribute.
+    # See https://stackoverflow.com/a/61480946
+    main_text: str = ""
+    _main_text: str = field(init=False, repr=False, default="")
+
     _last_part: dict[str, int] = field(
         default_factory=lambda: {"solution": 0, "text": 0}, repr=False
     )
@@ -34,15 +38,10 @@ class Question:
 
     @property
     def main_text(self) -> str:
-        """Main top-level question text."""
-        return self._main_text
+        r"""Main top-level question text.
 
-    @main_text.setter
-    def main_text(self, value: Union[pf.Element, str]) -> 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.
+        Setting the attribute multiple times appends to the current value with a newline.
+        This allows question text to be dynamically appended.
 
         Examples:
             >>> from in2lambda.api.question import Question
@@ -52,7 +51,28 @@ class Question:
             >>> question.main_text
             'hello\nthere'
         """
-        text_value = value if isinstance(value, str) else pf.stringify(value, False)
+        return self._main_text
+
+    @main_text.setter
+    def main_text(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.
+        """
+        # Converts the inputted value into a string, stored in text_value
+        match value:
+            case str():
+                text_value = value
+            case property():
+                # Use default value when no value set at initialisation.
+                # See https://stackoverflow.com/a/61480946
+                text_value = self.main_text
+            case pf.Element():
+                text_value = pf.stringify(value, False)
+
         if self._main_text:
             self._main_text += "\n"
         self._main_text += text_value
@@ -69,7 +89,7 @@ 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(text='part a', worked_solution='part a solution')], images=[], main_text='')
             >>> question.add_part_text("part b")
             >>> question.add_part_text("part c")
             >>> question.add_solution("Solution for b")
@@ -77,12 +97,12 @@ class Question:
             >>> 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='')
+Part(text='part c', worked_solution='Solution for b')], images=[], main_text='')
             >>> 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='')
+Part(text='part c', worked_solution='We now have a solution for c!')], images=[], main_text='')
         """
         elem_text = elem if isinstance(elem, str) else pf.stringify(elem)
 
@@ -111,13 +131,13 @@ 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(text='part a', worked_solution='part a solution')], images=[], main_text='')
             >>> # 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='')
+Part(text='part b', worked_solution='part b solution')], images=[], main_text='')
         """
         elem_text = elem if isinstance(elem, str) else pf.stringify(elem)
 

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/filters/PartsSepSol/filter.py

@@ -72,7 +72,9 @@ def pandoc_filter(
             # Add each part solution/text
             # For the solution, prepend any top level answer text to each part answer
             for part in lettered_parts:
-                module.current_question.add_solution(
-                    spaced_blurb + part
-                ) if parsing_answers else module.current_question.add_part_text(part)
+                (
+                    module.current_question.add_solution(spaced_blurb + part)
+                    if parsing_answers
+                    else module.current_question.add_part_text(part)
+                )
     return None

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/filters/markdown.py

@@ -120,7 +120,10 @@ def filter(
         [pf.Element, pf.elements.Doc, Module, bool],
         Optional[pf.Str],
     ]
-) -> Callable[[pf.Element, pf.elements.Doc, Module, str, bool], Optional[pf.Str],]:
+) -> Callable[
+    [pf.Element, pf.elements.Doc, Module, str, bool],
+    Optional[pf.Str],
+]:
     """Python decorator to make generic LaTeX elements markdown readable.
 
     As an example, part of the process involves putting dollar signs around maths

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/json_convert/json_convert.py

@@ -50,7 +50,7 @@ def converter(
                 )
 
         # Output file
-        filename = "Question " + str(i + 1)
+        filename = "question_" + str(i + 1)
 
         # create directory to put the questions
         os.makedirs(output_dir, exist_ok=True)

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/json_convert/minimal_template.json

@@ -1,5 +1,4 @@
 {
-  "isPublished": false,
   "masterContent": "Top level question here",
   "parts": [
     {
@@ -17,6 +16,7 @@
       ]
     }
   ],
+  "publish": false,
   "questionSettings": {
     "displayFinalAnswer": true,
     "displayStructuredTutorial": true,

{in2lambda-0.3.1 → in2lambda-0.3.2}/in2lambda/main.py

@@ -9,7 +9,6 @@ import rich_click as click
 
 import in2lambda.filters
 from in2lambda.api.module import Module
-from in2lambda.json_convert import json_convert
 
 
 def file_type(file: str) -> str:
@@ -40,7 +39,17 @@ def file_type(file: str) -> str:
     match (extension := file.split(".")[-1].lower()):
         case "tex" | "latex" | "ltx":
             return "latex"
-        case "md" | "rmd" | "markdown" | "mdown" | "mdwn" | "mkd" | "mkdn" | "text" | "txt":
+        case (
+            "md"
+            | "rmd"
+            | "markdown"
+            | "mdown"
+            | "mdwn"
+            | "mkd"
+            | "mkdn"
+            | "text"
+            | "txt"
+        ):
             return "markdown"
         case "docx":
             return "docx"  # Pandoc doesn't seem to support doc
@@ -71,9 +80,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
-        Module(questions=[Question(title='', parts=[Part(text=..., worked_solution=''), ...], images=[], _main_text='This is a sample question\n\n'), ...])
+        Module(questions=[Question(title='', parts=[Part(text=..., worked_solution=''), ...], images=[], main_text='This is a sample question\n\n'), ...])
         >>> runner(f"{os.path.dirname(in2lambda.__file__)}/filters/PartsOneSol/example.tex", "PartsOneSol") # doctest: +ELLIPSIS
-        Module(questions=[Question(title='', parts=[Part(text='This is part (a)\n\n', worked_solution=''), ...], images=[], _main_text='Here is some preliminary question information that might be useful.'), ...)
+        Module(questions=[Question(title='', parts=[Part(text='This is part (a)\n\n', worked_solution=''), ...], images=[], main_text='Here is some preliminary question information that might be useful.'), ...)
     """
     # The list of questions for Lambda Feedback as a Python API.
     module = Module()
@@ -112,7 +121,7 @@ def runner(
 
     # Read the Python API format and convert to JSON.
     if output_dir is not None:
-        json_convert.main(module.questions, output_dir)
+        module.to_json(output_dir)
 
     return module
 

{in2lambda-0.3.1 → in2lambda-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "in2lambda"
-version = "0.3.1"
+version = "0.3.2"
 description = "Converts content ready for import into Lambda Feedback"
 authors = []
 license = "MIT"
@@ -23,25 +23,25 @@ documentation = "https://lambda-feedback.github.io/in2lambda"
 
 [tool.poetry.dependencies]
 python = "^3.10"
-panflute = "^2.3.0"
-rich-click = "^1.7.2"
-beartype = "^0.16.4"
+panflute = "^2.3.1"
+rich-click = "^1.7.4"
+beartype = "^0.17.2"
 
 [tool.poetry.scripts]
 in2lambda = "in2lambda.main:cli"
 
 [tool.poetry.group.dev.dependencies]
-black = "^23.12.0"
+black = "^24.3.0"
 isort = "^5.13.2"
 pydocstyle = "^6.3.0"
-mypy = "^1.7.1"
-pytest = "^7.4.3"
+mypy = "^1.9.0"
+pytest = "^8.1.1"
 pytest-cov = "^4.1.0"
-pytest-sugar = "^0.9.7"
-pre-commit = "^3.6.0"
+pytest-sugar = "^1.0.0"
+pre-commit = "^3.6.2"
 
 [tool.poetry.group.docs.dependencies]
-furo = "^2023.9.10"
+furo = "^2024.1.29"
 myst-parser = "^2.0.0"
 sphinx = "^7.2.6"
 sphinx-copybutton = "^0.5.2"

in2lambda-0.3.1/in2lambda/filters/Table_PartSolPartSol/__init__.py

@@ -1,4 +0,0 @@
-"""Filter and example TeX file for the PartSolPartSol filter.
-
-See the filter.py file for the use cases of this filter.
-"""

in2lambda-0.3.1/in2lambda/filters/Table_PartSolPartSol/example.md

@@ -1,195 +0,0 @@
-+-----+----------------------------------------------------------------+
-| Q | A Frahm\'s tachometer for measuring the rotational speed of |
-| 1.1 | machinery consists of many small cantilever spring steel |
-| | strips, each being rigidly fastened to the frame of the |
-| | instrument at one end and having a mass at the other (free) |
-| | end. A strip will vibrate (and so give a visual indication) |
-| | when the speed of the machine is equal to the strip\'s natural |
-| | frequency. One such strip is 1 mm thick, 7 mm wide and 50 mm |
-| | long. Calculate the mass required at the free end so that the |
-| | natural frequency will correspond to 1800 rev/min. |
-| | |
-| | **(0.082 kg)** |
-+=====+================================================================+
-| | Hint: Obtain the cantilever stiffness from data book. |
-+-----+----------------------------------------------------------------+
-| | |
-+-----+----------------------------------------------------------------+
-| | ![](media/image1.png){width="3.9776432633420824in" |
-| | height="2.075301837270341in"} |
-| | |
-| | a\) Cantilever steel strip and b) equivalent mass and spring |
-| | system |
-| | |
-| | Calculate the effective stiffness of the beam by considering |
-| | the standard formula of deflection (Engineering Data and |
-| | Formulae Handbook). |
-| | |
-| | ------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | |
-| | $$\mathbf{Stiffness}\mathbf{\ }\left( \mathbf{k} \rig |
-|     | ht)\mathbf{=}\frac{\mathbf{Force}}{\mathbf{Displacement}}$$ |
-| | ------------------------- |
-| | ------------------------------------------------------------- |
-| | ----------------------------------------------------- -------- |
-| | |
-| | $\delta = \frac{FL^{3}}{3EI}$ where $I = \frac{bd^{3} |
-|     | }{12}$ (from Data and Formulae Handbook) |
-| | |
-| | $$\mathbf{\theref                                            |
-|     | ore}$$ $$\ \frac{F}{\delta} = k = \frac{Ebd^{3}}{4L^{3}}$$ |
-| | |
-| | ------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | |
-| | The natural frequency is given by, |
-| | |
-| | ------------------------------------ |
-| | -------------------------------------------------------------- |
-| | $$\mathbf{\omega}_{                                 |
-|     | \mathbf{n}}\mathbf{=}\sqrt{\frac{\mathbf{k}}{\mathbf{m}}}$$ |
-| | -------- --------------------------- |
-| | ----------------------------------------------------- -------- |
-| | |
-| | ------------------------------------ |
-| | -------------------------------------------------------------- |
-| | |
-| | so, |
-| | |
-| | ------------------------------------------------------ |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | $$\mathbf{\omega}_{\               |
-|     | mathbf{n}}^{\mathbf{2}}\mathbf{=}\frac{\mathbf{Eb}\mathbf{d}^{ |
-|     | \mathbf{3}}}{\mathbf{4}\mathbf{L}^{\mathbf{3}}\mathbf{m}}$$ |
-| | ------------------------- ---------------------------- |
-| | -------------------------------------------------------------- |
-| | ----------------------------------------------------- -------- |
-| | $$\mathbf{\therefore}$$ $$m = \frac{Edb^{3}}               |
-|     | {4L^{3}\omega_{n}^{2}}$$ |
-| | |
-| | |
-| | ------------------------------------------------------ |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | |
-| | Remember to convert from rpm to rad/s: ($\omega_{n}$ = |
-| | 188.5 rad/s) |
-| | |
-| | ------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | $$\mathbf{\                                                  |
-|     | therefore}$$ $$\mathbf{m =}\frac{\mathbf{207 \times 1}\mathb |
-|     | f{0}^{\mathbf{9}}\mathbf{\times 7 \times}\mathbf{10}^{\mathbf{ |
-|     | - 3}}\mathbf{\times}\left( \mathbf{1 \times 1}\mathbf{0}^{\mat |
-|     | hbf{- 3}} \right)^{\mathbf{3}}}{\mathbf{4 \times 0.0}\mathbf{5 |
-|     | }^{\mathbf{3}}\mathbf{\times}\mathbf{188.5}^{\mathbf{2}}}$$ |
-| | ------------------- |
-| | ------ ------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | ----------------------------------------------------- -------- |
-| | $$\mathbf{\                                                  |
-|     | therefore}$$ $$m\mathbf{=}\boxed{\mathbf{0.082\ kg}}$$ |
-| | |
-| | |
-| | |
-| | |
-| | |
-| | ------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | -------------------------------------------------------------- |
-+-----+----------------------------------------------------------------+
-| | |
-+-----+----------------------------------------------------------------+
-| Q | A circular diaphragm, fixed all round its edge, has a natural |
-| 1.2 | frequency of 5000 Hz. When an additional mass of 0.5 kg is |
-| | attached to the centre of the diaphragm, the natural frequency |
-| | is reduced to 4900 Hz. What are the effective mass and |
-| | effective stiffness of the diaphragm, both referred to the |
-| | central point |
-| | |
-| | **(12.14 kg,12.0 GN/m)** |
-+-----+----------------------------------------------------------------+
-| | Hint: Write the natural frequency formula twice, considering |
-| | the cases of with and without added mass. |
-+-----+----------------------------------------------------------------+
-| | The diaphragm has effective mass, $m$ and effective stiffness, |
-| | $k$ which are to be determined. The original natural frequency |
-| | is simply given by $\sqrt{\frac{k}{m}}$ . When a 0.5 kg mass |
-| | is added to the centre of the diaphragm, which is the point of |
-| | maximum motion, the effective mass is increased by 0.5 kg. |
-| | |
-| | ![](media/image2.png){width="2.2402777777777776in" |
-| | height="1.4996205161854768in"} |
-| | |
-| | > Therefore, |
-| | |
-| | ---- |
-| | -------------------------------------------------------------- |
-| | |
-| | $$\omega_{n1} = \sqrt{\frac{k}{m_{1}}}$$ \(1\) |
-| | ---- |
-| | ---- ------------------------------------------------ -------- |
-| | |
-| | $$\omega_{n2} = \sqrt{\frac{k}{m_{1} + 0.5}}$$ \(2\) |
-| | |
-| | ---- |
-| | -------------------------------------------------------------- |
-| | |
-| | The two equations are used to solve for two unknowns, |
-| | |
-| | From equ (1), |
-| | |
-| | ------------------------------------------------------------ |
-| | $$k = \omega_{n1}^{2}m_{1}$$ \(3\) |
-| | -------- ------------------------------------------ -------- |
-| | |
-| | ------------------------------------------------------------ |
-| | |
-| | Substitute equ (3) into equ (2), |
-| | |
-| | ----------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | $$\omega_{n2}^{2} = \frac{\ome                      |
-|     | ga_{n1}^{2}m_{1}}{m_{1} + 0.5}$$ |
-| | -------- -------------------------------------- |
-| | ----------------------------------------------------- -------- |
-| | $$m_{1}\left( \omega_{n1}^{2}                       |
-|     | - \omega_{n2}^{2} \right) + \frac{\omega_{n2}^{2}}{2} = 0$$ |
-| | |
-| | ----------------------------------------------- |
-| | -------------------------------------------------------------- |
-| | |
-| | > Remember to convert Hz to rad/s. |
-| | |
-| | +-------+-----------------------------------------+-------+ |
-| | | | $$m_{1}                                 |       |    |
-|     | |       |  = \frac{\omega_{n2}^{2}}{2\left( \omeg |       |    |
-|     | |       | a_{n1}^{2} - \omega_{n2}^{2} \right)}$$ | | |
-| | | | | | |
-| | | | $$\mat                                  |       |    |
-|     | |       | hbf{\ \ \ \ \ \ \  =}\frac{(4900 \times |       |    |
-|     | |       |  2\pi)^{2}}{2\left( (5000 \times 2\pi)^ |       |    |
-|     | |       | {2} - (4900 \times 2\pi)^{2} \right)}$$ | | |
-| | | | | | |
-| | | | $$\mathbf{\ \ \                         |       |    |
-|     | |       | \ \ \ \  =}\boxed{\mathbf{12.13\ kg}}$$ | | |
-| | +=======+=========================================+=======+ |
-| | +-------+-----------------------------------------+-------+ |
-| | |
-| | > And from equ (3), $k = \boxed{\mathbf{12.0\ GN/m}}$ |
-+-----+----------------------------------------------------------------+
-| | |
-+-----+----------------------------------------------------------------+

in2lambda-0.3.1/in2lambda/filters/Table_PartSolPartSol/filter.py

@@ -1,61 +0,0 @@
-"""A solution appears after each individual part."""
-
-from collections import deque
-from typing import Optional
-
-import panflute as pf
-
-from in2lambda.api.module import Module
-from in2lambda.filters.markdown import filter
-
-
-@filter
-def pandoc_filter(
-    elem: pf.Element,
-    doc: pf.elements.Doc,
-    module: Module,
-    parsing_answers: bool,
-) -> Optional[pf.Str]:
-    """A Pandoc filter that parses and translates various TeX elements.
-
-    Args:
-        elem: The current TeX element being processed. This could be a paragraph,
-            ordered list, etc.
-        doc: A Pandoc document container - essentially the Pandoc AST.
-        module: The Python API that is used to store the result after processing
-            the TeX file.
-        parsing_answers: Whether an answers-only document is currently being parsed.
-
-    Returns:
-        Converted TeX elements for the AST where required
-        e.g. replaces math equations so that they are surrounded by $.
-    """
-    # Question text (ListItem -> List -> Doc)
-    if isinstance(elem, pf.Table):
-        match type(elem):
-            case pf.Para:
-                pandoc_filter.solutions = deque()
-                if hasattr(pandoc_filter, "question"):
-                    pandoc_filter.question.append(pf.stringify(elem))
-                else:
-                    pandoc_filter.question = [pf.stringify(elem)]
-            case pf.OrderedList:
-                for listItem in elem.content:
-                    part = [
-                        pf.stringify(item)
-                        for item in listItem.content
-                        if not isinstance(item, pf.Div)
-                    ]
-                    module.current_question.add_part_text("\n".join(part))
-                    module.current_question.add_solution(
-                        pandoc_filter.solutions.popleft()
-                    )
-
-    if isinstance(elem, pf.Div):
-        pandoc_filter.solutions.append(pf.stringify(elem))
-        if pandoc_filter.question:
-            module.add_question(main_text="\n".join(pandoc_filter.question))
-            module.current_question.add_solution(pf.stringify(elem))
-            module.current_question._last_part["solution"] -= 1
-        pandoc_filter.question = []
-    return None