dp_wizard_templates 0.3.0__tar.gz → 0.4.0__tar.gz

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/.coveragerc

@@ -13,5 +13,5 @@ omit =
 show_missing = True
 skip_covered = True
 fail_under = 100
-exclude_also =
-  template
+# Negative look-ahead: We *do* want to cover test functions.
+exclude_also = def (?!test)\w*template

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.4.0
+
+- Safer template filling, and option to ignore slots [#20](https://github.com/opendp/dp-wizard-templates/pull/20)
+- Check for `root` kwarg, and fix test coverage [#19](https://github.com/opendp/dp-wizard-templates/pull/19)
+
 ## 0.3.0
 
 - Show all errors, and support comment blocks [#12](https://github.com/opendp/dp-wizard-templates/pull/12)

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dp_wizard_templates
-Version: 0.3.0
+Version: 0.4.0
 Summary: Code templating tools
 Author-email: The OpenDP Project <info@opendp.org>
 Description-Content-Type: text/markdown

dp_wizard_templates-0.4.0/dp_wizard_templates/VERSION

@@ -0,0 +1 @@
+0.4.0

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/dp_wizard_templates/code_template.py

@@ -1,8 +1,13 @@
-from typing import Optional, Callable
+from typing import Optional, Callable, Iterable
 from pathlib import Path
 import inspect
 import re
 import black
+import json
+
+
+class TemplateException(Exception):
+    pass
 
 
 def _get_body(func):
@@ -12,46 +17,71 @@ def _get_body(func):
     if not re.match(r"def \w+\((\w+(, \w+)*)?\):", first_line.strip()):
         # Parsing to AST and unparsing is a more robust option,
         # but more complicated.
-        raise Exception(f"def and parameters should fit on one line: {first_line}")
+        raise TemplateException(
+            f"def and parameters should fit on one line: {first_line}"
+        )
 
     # The "def" should not be in the output,
     # and cleandoc handles the first line differently.
     source_lines[0] = ""
     body = inspect.cleandoc("\n".join(source_lines))
-    body = re.sub(
-        r"\s*#\s+type:\s+ignore\s*",
-        "\n",
-        body,
-    )
-    body = re.sub(
-        r"\s*#\s+noqa:.+",
-        "",
-        body,
-    )
+    comments_to_strip = [
+        r"\s+#\s+type:\s+ignore\s*",
+        r"\s+#\s+noqa:.+\s*",
+        r"\s+#\s+pragma:\s+no cover\s*",
+    ]
+    for comment_re in comments_to_strip:
+        body = re.sub(
+            comment_re,
+            "\n",
+            body,
+        )
+
     return body
 
 
+def _check_repr(value):
+    """
+    Confirms that the string returned by repr()
+    can be evaluated to recreate the original value.
+    Takes a conservative approach by checking
+    if the value can be serialized to JSON.
+    """
+    try:
+        json.dumps(value)
+    except TypeError as e:
+        raise TemplateException(e)
+    return repr(value)
+
+
 class Template:
     def __init__(
         self,
         template: str | Callable,
         root: Optional[Path] = None,
+        ignore: Iterable[str] = ("TODO",),
     ):
-        if root is not None:
-            template_name = f"_{template}.py"
-            template_path = root / template_name
-            self._source = f"'{template_name}'"
-            self._template = template_path.read_text()
-        else:
+        if root is None:
             if callable(template):
                 self._source = "function template"
                 self._template = _get_body(template)
             else:
                 self._source = "string template"
                 self._template = template
+        else:
+            if callable(template):
+                raise TemplateException(
+                    "If template is function, root kwarg not allowed"
+                )
+            else:
+                template_name = f"_{template}.py"
+                template_path = root / template_name
+                self._source = f"'{template_name}'"
+                self._template = template_path.read_text()
         # We want a list of the initial slots, because substitutions
         # can produce sequences of upper case letters that could be mistaken for slots.
         self._initial_slots = self._find_slots()
+        self._ignore = ignore
 
     def _find_slots(self) -> set[str]:
         # Slots:
@@ -75,7 +105,7 @@ class Template:
         for k, v in kwargs.items():
             function(k, v, errors)
         if errors:
-            raise Exception(self._make_message(errors))
+            raise TemplateException(self._make_message(errors))
 
     def _fill_inline_slots(
         self,
@@ -141,7 +171,7 @@ class Template:
         """
         Fill in string or numeric values. `repr` is called before filling.
         """
-        self._fill_inline_slots(stringifier=repr, **kwargs)
+        self._fill_inline_slots(stringifier=_check_repr, **kwargs)
         return self
 
     def fill_code_blocks(self, **kwargs) -> "Template":
@@ -168,10 +198,10 @@ class Template:
         return self
 
     def finish(self, reformat: bool = False) -> str:
-        unfilled_slots = self._initial_slots & self._find_slots()
+        unfilled_slots = (self._initial_slots & self._find_slots()) - set(self._ignore)
         if unfilled_slots:
             errors = [f"'{slot}' slot not filled" for slot in unfilled_slots]
-            raise Exception(self._make_message(errors))
+            raise TemplateException(self._make_message(errors))
 
         if reformat:
             self._template = black.format_str(self._template, mode=black.Mode())

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/index.html

@@ -7752,7 +7752,7 @@ to produce other artifacts without adding clutter.</p>
 </div>
 </div>
 </div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=746eea6a">
+<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=50f5c776">
 <div class="jp-Cell-inputWrapper" tabindex="0">
 <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
 </div>
@@ -7772,7 +7772,7 @@ and configure pytest (<code>--ignore-glob '**/templates/</code>) and pyright
 (<code>ignore = ["**/templates/"]</code>) to ignore them.</li>
 <li>For template functions, you might have a consistent naming
 convention, and configure coverage (<code>exclude_also = def template_</code>)
-to exclude them as well.</li>
+to exclude them as well, or else use <code># pragma: no cover</code>.</li>
 </ul>
 </div>
 </div>

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/tests/test_code_template.py

@@ -1,5 +1,59 @@
+from pathlib import Path
+
 import pytest
-from dp_wizard_templates.code_template import Template
+from dp_wizard_templates.code_template import Template, TemplateException
+
+
+def test_non_repr_value():
+    def template(VALUE):
+        print(VALUE)
+
+    with pytest.raises(
+        TemplateException,
+        match=r"Object of type set is not JSON serializable",
+    ):
+        Template(template).fill_values(VALUE={1, 2, 3})
+
+
+def test_ignore_todo_by_default():
+    def template():
+        print("TODO")
+
+    assert Template(template).finish() == 'print("TODO")'
+
+
+def test_ignore_kwarg():
+    def template():
+        print("IGNORE_ME")
+
+    with pytest.raises(
+        TemplateException,
+        match=r"'IGNORE_ME' slot not filled",
+    ):
+        Template(template).finish()
+
+    assert Template(template, ignore={"IGNORE_ME"}).finish() == 'print("IGNORE_ME")'
+
+
+def test_strip_pragma():
+    def template():
+        pass  # pragma: no cover
+
+    assert Template(template).finish() == "pass\n"
+
+
+def test_strip_noqa():
+    def template():
+        pass  # noqa: B950 (explanation here!)
+
+    assert Template(template).finish() == "pass\n"
+
+
+def test_strip_type_ignore():
+    def template():
+        pass  # type: ignore
+
+    assert Template(template).finish() == "pass\n"
 
 
 def test_def_too_long():
@@ -9,7 +63,9 @@ def test_def_too_long():
     ):
         print(BEGIN, END)
 
-    with pytest.raises(Exception, match=r"def and parameters should fit on one line"):
+    with pytest.raises(
+        TemplateException, match=r"def and parameters should fit on one line"
+    ):
         Template(template)
 
 
@@ -36,7 +92,7 @@ def test_fill_expressions():
 def test_fill_expressions_missing_slots_in_template():
     template = Template("No one ... the ... ...!")
     with pytest.raises(
-        Exception,
+        TemplateException,
         match=r"no 'ADJ' slot to fill with 'Spanish', "
         r"no 'NOUN' slot to fill with 'Inquisition', "
         r"no 'VERB' slot to fill with 'expects':",
@@ -51,7 +107,7 @@ def test_fill_expressions_missing_slots_in_template():
 def test_fill_expressions_extra_slots_in_template():
     template = Template("No one VERB ARTICLE ADJ NOUN!")
     with pytest.raises(
-        Exception, match=r"'ARTICLE' slot not filled, 'VERB' slot not filled"
+        TemplateException, match=r"'ARTICLE' slot not filled, 'VERB' slot not filled"
     ):
         template.fill_expressions(
             ADJ="Spanish",
@@ -71,7 +127,7 @@ def test_fill_values():
 
 def test_fill_values_missing_slot_in_template():
     template = Template("assert [STRING] * ... == LIST")
-    with pytest.raises(Exception, match=r"no 'NUM' slot to fill with '3'"):
+    with pytest.raises(TemplateException, match=r"no 'NUM' slot to fill with '3'"):
         template.fill_values(
             STRING="🙂",
             NUM=3,
@@ -81,7 +137,7 @@ def test_fill_values_missing_slot_in_template():
 
 def test_fill_values_extra_slot_in_template():
     template = Template("CMD [STRING] * NUM == LIST")
-    with pytest.raises(Exception, match=r"'CMD' slot not filled"):
+    with pytest.raises(TemplateException, match=r"'CMD' slot not filled"):
         template.fill_values(
             STRING="🙂",
             NUM=3,
@@ -144,10 +200,16 @@ def test_fill_comment_block():
     assert filled == "# placeholder"
 
 
+def test_finish_reformat():
+    template = Template("print( 'messy','code!' )#comment")
+    filled = template.finish(reformat=True)
+    assert filled == 'print("messy", "code!")  # comment\n'
+
+
 def test_fill_comment_block_without_comment():
     template = Template("SLOT")
     with pytest.raises(
-        Exception,
+        TemplateException,
         match=r"In string template, no 'SLOT' slot to fill with 'placeholder' "
         r"\(comment slots must be prefixed with '#'\)",
     ):
@@ -156,14 +218,16 @@ def test_fill_comment_block_without_comment():
 
 def test_fill_blocks_missing_slot_in_template_alone():
     template = Template("No block slot")
-    with pytest.raises(Exception, match=r"no 'SLOT' slot to fill with 'placeholder':"):
+    with pytest.raises(
+        TemplateException, match=r"no 'SLOT' slot to fill with 'placeholder':"
+    ):
         template.fill_code_blocks(SLOT="placeholder").finish()
 
 
 def test_fill_blocks_missing_slot_in_template_not_alone():
     template = Template("No block SLOT")
     with pytest.raises(
-        Exception,
+        TemplateException,
         match=r"no 'SLOT' slot to fill with 'placeholder' "
         r"\(block slots must be alone on line\)",
     ):
@@ -172,14 +236,25 @@ def test_fill_blocks_missing_slot_in_template_not_alone():
 
 def test_fill_blocks_extra_slot_in_template():
     template = Template("EXTRA\nSLOT")
-    with pytest.raises(Exception, match=r"'EXTRA' slot not filled"):
+    with pytest.raises(TemplateException, match=r"'EXTRA' slot not filled"):
         template.fill_code_blocks(SLOT="placeholder").finish()
 
 
 def test_fill_blocks_not_string():
     template = Template("SOMETHING")
     with pytest.raises(
-        Exception,
+        TemplateException,
         match=r"for 'SOMETHING' slot, expected string, not '123'",
     ):
         template.fill_code_blocks(SOMETHING=123).finish()
+
+
+def test_no_root_kwarg_with_function_template():
+    def template():
+        pass
+
+    with pytest.raises(
+        TemplateException,
+        match=r"If template is function, root kwarg not allowed",
+    ):
+        Template(template, root=Path("not-allowed"))

{dp_wizard_templates-0.3.0 → dp_wizard_templates-0.4.0}/tests/test_index_html.py

@@ -200,7 +200,7 @@ notebook_html = convert_nb_to_html(notebook_ipynb)
 #   (`ignore = ["**/templates/"]`) to ignore them.
 # - For template functions, you might have a consistent naming
 #   convention, and configure coverage (`exclude_also = def template_`)
-#   to exclude them as well.
+#   to exclude them as well, or else use `# pragma: no cover`.
 
 # # Coda
 

dp_wizard_templates-0.3.0/dp_wizard_templates/VERSION

@@ -1 +0,0 @@
-0.3.0