dp_wizard_templates 0.2.0__py2.py3-none-any.whl → 0.3.0__py2.py3-none-any.whl

dp_wizard_templates/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

dp_wizard_templates/code_template.py

@@ -1,3 +1,5 @@
+from typing import Optional, Callable
+from pathlib import Path
 import inspect
 import re
 import black
@@ -30,7 +32,11 @@ def _get_body(func):
 
 
 class Template:
-    def __init__(self, template, root=None):
+    def __init__(
+        self,
+        template: str | Callable,
+        root: Optional[Path] = None,
+    ):
         if root is not None:
             template_name = f"_{template}.py"
             template_path = root / template_name
@@ -47,7 +53,7 @@ class Template:
         # can produce sequences of upper case letters that could be mistaken for slots.
         self._initial_slots = self._find_slots()
 
-    def _find_slots(self):
+    def _find_slots(self) -> set[str]:
         # Slots:
         # - are all caps or underscores
         # - have word boundary on either side
@@ -55,75 +61,117 @@ class Template:
         slot_re = r"\b[A-Z][A-Z_]{2,}\b"
         return set(re.findall(slot_re, self._template))
 
-    def fill_expressions(self, **kwargs):
-        """
-        Fill in variable names, or dicts or lists represented as strings.
-        """
-        for k, v in kwargs.items():
-            k_re = re.escape(k)
-            self._template, count = re.subn(rf"\b{k_re}\b", str(v), self._template)
-            if count == 0:
-                raise Exception(
-                    f"No '{k}' slot to fill with '{v}' in "
-                    f"{self._source}:\n\n{self._template}"
-                )
-        return self
+    def _make_message(self, errors: list[str]) -> str:
+        return (
+            f"In {self._source}, " + ", ".join(sorted(errors)) + f":\n{self._template}"
+        )
 
-    def fill_values(self, **kwargs):
-        """
-        Fill in string or numeric values. `repr` is called before filling.
-        """
+    def _loop_kwargs(
+        self,
+        function: Callable[[str, str, list[str]], None],
+        **kwargs,
+    ) -> None:
+        errors = []
         for k, v in kwargs.items():
+            function(k, v, errors)
+        if errors:
+            raise Exception(self._make_message(errors))
+
+    def _fill_inline_slots(
+        self,
+        stringifier: Callable[[str], str],
+        **kwargs,
+    ) -> None:
+        def function(k, v, errors):
             k_re = re.escape(k)
-            self._template, count = re.subn(rf"\b{k_re}\b", repr(v), self._template)
+            self._template, count = re.subn(
+                rf"\b{k_re}\b", stringifier(v), self._template
+            )
             if count == 0:
-                raise Exception(
-                    f"No '{k}' slot to fill with '{v}' in "
-                    f"{self._source}:\n\n{self._template}"
-                )
-        return self
+                errors.append(f"no '{k}' slot to fill with '{v}'")
 
-    def fill_blocks(self, **kwargs):
-        """
-        Fill in code blocks. Slot must be alone on line.
-        """
-        for k, v in kwargs.items():
+        self._loop_kwargs(function, **kwargs)
+
+    def _fill_block_slots(
+        self,
+        prefix_re: str,
+        splitter: Callable[[str], list[str]],
+        **kwargs,
+    ) -> None:
+        def function(k, v, errors):
             if not isinstance(v, str):
-                raise Exception(f"For {k} in {self._source}, expected string, not {v}")
+                errors.append(f"for '{k}' slot, expected string, not '{v}'")
+                return
 
             def match_indent(match):
                 # This does what we want, but binding is confusing.
                 return "\n".join(
-                    match.group(1) + line for line in v.split("\n")  # noqa: B023
+                    match.group(1) + line for line in splitter(v)  # noqa: B023
                 )
 
             k_re = re.escape(k)
             self._template, count = re.subn(
-                rf"^([ \t]*){k_re}$",
+                rf"^([ \t]*{prefix_re}){k_re}$",
                 match_indent,
                 self._template,
                 flags=re.MULTILINE,
             )
             if count == 0:
-                base_message = (
-                    f"No '{k}' slot to fill with '{v}' in "
-                    f"{self._source}:\n\n{self._template}"
-                )
+                base_message = f"no '{k}' slot to fill with '{v}'"
                 if k in self._template:
-                    raise Exception(
-                        f"Block slots must be alone on line; {base_message}"
+                    note = (
+                        "comment slots must be prefixed with '#'"
+                        if prefix_re
+                        else "block slots must be alone on line"
                     )
-                raise Exception(base_message)
+                    errors.append(f"{base_message} ({note})")
+                else:
+                    errors.append(base_message)
+
+        self._loop_kwargs(function, **kwargs)
+
+    def fill_expressions(self, **kwargs) -> "Template":
+        """
+        Fill in variable names, or dicts or lists represented as strings.
+        """
+        self._fill_inline_slots(stringifier=str, **kwargs)
+        return self
+
+    def fill_values(self, **kwargs) -> "Template":
+        """
+        Fill in string or numeric values. `repr` is called before filling.
+        """
+        self._fill_inline_slots(stringifier=repr, **kwargs)
         return self
 
-    def finish(self, reformat=False) -> str:
+    def fill_code_blocks(self, **kwargs) -> "Template":
+        """
+        Fill in code blocks. Slot must be alone on line.
+        """
+
+        def splitter(s):
+            return s.split("\n")
+
+        self._fill_block_slots(prefix_re=r"", splitter=splitter, **kwargs)
+        return self
+
+    def fill_comment_blocks(self, **kwargs) -> "Template":
+        """
+        Fill in comment blocks. Slot must be commented.
+        """
+
+        def splitter(s):
+            stripped = [line.strip() for line in s.split("\n")]
+            return [line for line in stripped if line]
+
+        self._fill_block_slots(prefix_re=r"#\s+", splitter=splitter, **kwargs)
+        return self
+
+    def finish(self, reformat: bool = False) -> str:
         unfilled_slots = self._initial_slots & self._find_slots()
         if unfilled_slots:
-            slots_str = ", ".join(sorted(f"'{slot}'" for slot in unfilled_slots))
-            raise Exception(
-                f"{slots_str} slot not filled "
-                f"in {self._source}:\n\n{self._template}"
-            )
+            errors = [f"'{slot}' slot not filled" for slot in unfilled_slots]
+            raise Exception(self._make_message(errors))
 
         if reformat:
             self._template = black.format_str(self._template, mode=black.Mode())

dp_wizard_templates/converters.py

@@ -30,7 +30,7 @@ class ConversionException(Exception):
 
 def convert_py_to_nb(
     python_str: str, title: str, execute: bool = False, reformat: bool = True
-):
+) -> str:
     """
     Given Python code as a string, returns a notebook as a string.
     Calls jupytext as a subprocess:
@@ -71,13 +71,13 @@ def convert_py_to_nb(
     return _clean_nb(json.dumps(nb_dict))
 
 
-def _stable_hash(lines: list[str]):
+def _stable_hash(lines: list[str]) -> str:
     import hashlib
 
     return hashlib.sha1("\n".join(lines).encode()).hexdigest()[:8]
 
 
-def _clean_nb(nb_json: str):
+def _clean_nb(nb_json: str) -> str:
     """
     Given a notebook as a string of JSON, remove the coda and pip output.
     (The code may produce reports that we do need,
@@ -104,7 +104,7 @@ def _clean_nb(nb_json: str):
     return json.dumps(nb, indent=1)
 
 
-def convert_nb_to_html(python_nb: str, numbered=True):
+def convert_nb_to_html(python_nb: str, numbered=True) -> str:
     notebook = nbformat.reads(python_nb, as_version=4)
     exporter = nbconvert.HTMLExporter(
         template_name="lab",

{dp_wizard_templates-0.2.0.dist-info → dp_wizard_templates-0.3.0.dist-info}/METADATA

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

dp_wizard_templates-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dp_wizard_templates/VERSION,sha256=VQYTU3_EiPOzcq90pAAYefASyEZbgW8bhcbTRGss-0k,5
+dp_wizard_templates/__init__.py,sha256=E2xrnvZGY24pU3PCryH4TmvhNYsLmxXCtfvIcYNbTYw,126
+dp_wizard_templates/code_template.py,sha256=BAt9vsvrusqR3mETsUE4HfsPgF3D0yPHgL8Q0no01h4,5735
+dp_wizard_templates/converters.py,sha256=0Ml_V71Z6zce2SaxDQMzYXg-5jQw2-NWChrY_9SCGIo,4359
+dp_wizard_templates/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dp_wizard_templates-0.3.0.dist-info/licenses/LICENSE,sha256=FDrIMeZPiT4g_4w0i1Ec4Bc8h9wfNytroheQN4508yU,1063
+dp_wizard_templates-0.3.0.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+dp_wizard_templates-0.3.0.dist-info/METADATA,sha256=uBCyEVM3KWsLChzbFCYT8nxjwdxvQeWMsGAKSKCiEYA,1881
+dp_wizard_templates-0.3.0.dist-info/RECORD,,

dp_wizard_templates-0.2.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-dp_wizard_templates/VERSION,sha256=kR_AxIywxwYB21d1qb7xt0DcTMn5tGOJufBWP-frlNc,5
-dp_wizard_templates/__init__.py,sha256=E2xrnvZGY24pU3PCryH4TmvhNYsLmxXCtfvIcYNbTYw,126
-dp_wizard_templates/code_template.py,sha256=HwnmKmJStkan9jkdyRQ4zVnJcvHWymzzCt8lwdTdtX4,4504
-dp_wizard_templates/converters.py,sha256=voLc2KlJ7WZGYMtA8x0pB1xBcLJs974uoX2nCJO7uD0,4331
-dp_wizard_templates-0.2.0.dist-info/licenses/LICENSE,sha256=FDrIMeZPiT4g_4w0i1Ec4Bc8h9wfNytroheQN4508yU,1063
-dp_wizard_templates-0.2.0.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
-dp_wizard_templates-0.2.0.dist-info/METADATA,sha256=zvMOoJELX1KP5e_3gIcimNjp62lDNyOd7BfkGahvdLg,1881
-dp_wizard_templates-0.2.0.dist-info/RECORD,,