in2lambda 0.3.1__tar.gz → 0.3.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: in2lambda
-Version: 0.3.1
+Version: 0.3.3
 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.3}/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,40 @@ 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 contents of the set directory
+            ...     sorted(os.listdir(f"{temp_dir}/set"))
+            ...     # Check the title of the first question
+            ...     with open(f"{temp_dir}/set/question_1.json") as file:
+            ...         print(f"Question 1's title: {json.load(file)['title']}")
+            ['set', 'set.zip']
+            ['media', 'question_1.json', 'question_2.json']
+            Question 1's title: Question 1
+
+        """
+        json_convert.main(self.questions, output_dir)

{in2lambda-0.3.1 → in2lambda-0.3.3}/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.3}/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.3}/in2lambda/filters/markdown.py

@@ -32,12 +32,12 @@ def image_directories(tex_file: str) -> list[str]:
         >>> temp_dir = tempfile.mkdtemp()
         >>> tex_file = os.path.join(temp_dir, 'test.tex')
         >>> with open(tex_file, 'w') as f:
-        ...     f.write("\graphicspath{{subdir1/}{subdir2/}{subdir3/}}")
+        ...     f.write("\\graphicspath{{subdir1/}{subdir2/}{subdir3/}}")
         45
         >>> image_directories(tex_file)
         ['subdir1/', 'subdir2/', 'subdir3/']
         >>> with open(tex_file, 'w') as f:
-        ...    f.write("\graphicspath{ { subdir1/ }, { subdir2/ }, { subdir3/ } }")
+        ...    f.write("\\graphicspath{ { subdir1/ }, { subdir2/ }, { subdir3/ } }")
         57
         >>> image_directories.cache_clear()
         >>> image_directories(tex_file)
@@ -78,7 +78,7 @@ def image_path(image_name: str, tex_file: str) -> Optional[str]:
         >>> temp_dir = tempfile.mkdtemp()
         >>> tex_file = os.path.join(temp_dir, 'test.tex')
         >>> with open(tex_file, 'w') as f:
-        ...     f.write("\graphicspath{{./subdir1/}{./subdir2/}{./subdir3/}}")
+        ...     f.write("\\graphicspath{{./subdir1/}{./subdir2/}{./subdir3/}}")
         51
         >>> # Example image in a relative subdirectory
         >>> sub_dir = os.path.join(temp_dir, 'subdir3')
@@ -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.3}/in2lambda/json_convert/json_convert.py

@@ -24,6 +24,15 @@ def converter(
     """
     # Create output by copying template
 
+    # create directory to put the questions
+    os.makedirs(output_dir, exist_ok=True)
+    output_question = os.path.join(output_dir, "set")
+    os.makedirs(output_question, exist_ok=True)
+
+    # create directory to put images - should be in set
+    output_image = os.path.join(output_question, "media")
+    os.makedirs(output_image, exist_ok=True)
+
     for i in range(len(ListQuestions)):
         output = deepcopy(template)
 
@@ -39,27 +48,19 @@ def converter(
         # add parts to the question file
         if ListQuestions[i].parts:
             output["parts"][0]["content"] = ListQuestions[i].parts[0].text
-            output["parts"][0]["workedSolution"][0]["content"] = (
+            output["parts"][0]["workedSolution"]["content"] = (
                 ListQuestions[i].parts[0].worked_solution
             )
             for j in range(1, len(ListQuestions[i].parts)):
                 output["parts"].append(deepcopy(template["parts"][0]))
                 output["parts"][j]["content"] = ListQuestions[i].parts[j].text
-                output["parts"][j]["workedSolution"][0]["content"] = (
+                output["parts"][j]["orderNumber"] = j
+                output["parts"][j]["workedSolution"]["content"] = (
                     ListQuestions[i].parts[j].worked_solution
                 )
 
         # Output file
-        filename = "Question " + str(i + 1)
-
-        # create directory to put the questions
-        os.makedirs(output_dir, exist_ok=True)
-        output_question = os.path.join(output_dir, filename)
-        os.makedirs(output_question, exist_ok=True)
-
-        # create directory to put image
-        output_image = os.path.join(output_question, "media")
-        os.makedirs(output_image, exist_ok=True)
+        filename = "question_" + str(i + 1)
 
         # write questions into directory
         with open(f"{output_question}/{filename}.json", "w") as file:

in2lambda-0.3.3/in2lambda/json_convert/minimal_template.json

@@ -0,0 +1,23 @@
+{
+  "displayFinalAnswer": true,
+  "displayStructuredTutorial": true,
+  "displayWorkedSolution": true,
+  "masterContent": "Top level question here",
+  "parts": [
+    {
+      "answer": "",
+      "content": "Part text here",
+      "orderNumber": 0,
+      "responseAreas": [],
+      "tutorial": [],
+      "universalPartId": "N/A",
+      "workedSolution": {
+        "content": "Part worked solution here",
+        "id": "N/A",
+        "title": ""
+      }
+    }
+  ],
+  "publish": false,
+  "title": "Question title here"
+}

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

@@ -1,7 +1,14 @@
 """The main input for in2lambda, defining both the CLT and main library function."""
 
+# This commented block makes it run the local files rather than the pip library (I think, I don't understand it. Kevin wrote it.)
+#
+# import sys
+# import os
+# sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
 import importlib
 import pkgutil
+import subprocess
 from typing import Optional
 
 import panflute as pf
@@ -9,7 +16,19 @@ import rich_click as click
 
 import in2lambda.filters
 from in2lambda.api.module import Module
-from in2lambda.json_convert import json_convert
+
+
+def docx_to_md(docx_file: str) -> str:
+    """Converts .docx files to markdown.
+
+    Args:
+        docx_file: A file path with the file extension included.
+
+    Returns:
+        the contents of the .docx file in markdown formatting
+    """
+    md_output = subprocess.check_output(["pandoc", docx_file, "-t", "markdown"])
+    return md_output.decode("utf-8")
 
 
 def file_type(file: str) -> str:
@@ -40,10 +59,20 @@ 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
+            return "docx"  # Pandoc doesn't seem to support .doc, and panflute doesn't like .docx.
     raise RuntimeError(f"Unsupported file extension: .{extension}")
 
 
@@ -71,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
-        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()
@@ -81,15 +110,20 @@ def runner(
     # Dynamically import the correct pandoc filter depending on the subject.
     filter_module = importlib.import_module(f"in2lambda.filters.{chosen_filter}.filter")
 
-    with open(question_file, "r", encoding="utf-8") as file:
-        text = file.read()
+    if file_type(question_file) == "docx":
+        # Convert .docx to md using Pandoc and proceed
+        text = docx_to_md(question_file)
+        input_format = "markdown"
+    else:
+        with open(question_file, "r", encoding="utf-8") as file:
+            text = file.read()
+
+        input_format = file_type(question_file)
 
     # Parse the Pandoc AST using the relevant panflute filter.
     pf.run_filter(
         filter_module.pandoc_filter,
-        doc=pf.convert_text(
-            text, input_format=file_type(question_file), standalone=True
-        ),
+        doc=pf.convert_text(text, input_format=input_format, standalone=True),
         module=module,
         tex_file=question_file,
         parsing_answers=False,
@@ -97,13 +131,20 @@ def runner(
 
     # If separate answer TeX file provided, parse that as well.
     if answer_file:
-        with open(answer_file, "r", encoding="utf-8") as file:
-            answer_text = file.read()
+
+        if file_type(answer_file) == "docx":
+
+            answer_text = docx_to_md(answer_file)
+            answer_format = "markdown"
+        else:
+            with open(answer_file, "r", encoding="utf-8") as file:
+                answer_text = file.read()
+            answer_format = file_type(answer_file)
 
         pf.run_filter(
             filter_module.pandoc_filter,
             doc=pf.convert_text(
-                answer_text, input_format=file_type(answer_file), standalone=True
+                answer_text, input_format=answer_format, standalone=True
             ),
             module=module,
             tex_file=answer_file,
@@ -112,7 +153,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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "in2lambda"
-version = "0.3.1"
+version = "0.3.3"
 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

in2lambda-0.3.1/in2lambda/json_convert/minimal_template.json

@@ -1,26 +0,0 @@
-{
-  "isPublished": false,
-  "masterContent": "Top level question here",
-  "parts": [
-    {
-      "answer": "",
-      "content": "Part text here",
-      "responseArea": [],
-      "tutorial": [],
-      "universalPartId": "N/A",
-      "workedSolution": [
-        {
-          "content": "Part worked solution here",
-          "id": "N/A",
-          "title": ""
-        }
-      ]
-    }
-  ],
-  "questionSettings": {
-    "displayFinalAnswer": true,
-    "displayStructuredTutorial": true,
-    "displayWorkedSolution": true
-  },
-  "title": "Question title here"
-}