style: Switch to black

Author: Alan Christie

decoder/decode_jinja2_3_0.py

@@ -7,28 +7,26 @@
 from jinja2.meta import find_undeclared_variables
 
 
-def decode(template_text: str,
-           variable_map: Optional[Dict[str, str]],
-           subject: str) -> Tuple[str, bool]:
-    """Decodes text expected to conform to Jinja2 (v3.0.x)
-    """
+def decode(
+    template_text: str, variable_map: Optional[Dict[str, str]], subject: str
+) -> Tuple[str, bool]:
+    """Decodes text expected to conform to Jinja2 (v3.0.x)"""
     assert template_text
     assert subject
 
     # Make a template from the text
-    env: jinja2.Environment = jinja2.\
-        Environment(undefined=jinja2.DebugUndefined)
+    env: jinja2.Environment = jinja2.Environment(undefined=jinja2.DebugUndefined)
     try:
         template: jinja2.Template = env.from_string(template_text)
     except TemplateSyntaxError as ex:
-        msg: str = f'TemplateSyntaxError with {subject}: {ex}'
+        msg: str = f"TemplateSyntaxError with {subject}: {ex}"
         return msg, False
 
     # Render (this works even if there are variables in the rendered text
     # The rendered text, when stripped of whitespace, must not be empty.
     rendered_text = template.render(variable_map).strip()
     if len(rendered_text) == 0:
-        msg = f'Rendered text for {subject} is blank'
+        msg = f"Rendered text for {subject} is blank"
         return msg, False
 
     # Check if rendering was done correctly.
@@ -40,9 +38,9 @@ def decode(template_text: str,
     undefined: Set[str] = find_undeclared_variables(abstract_syntax_tree)
     if undefined:
         # We
-        msg = f'Undefined template variables for {subject}:'
+        msg = f"Undefined template variables for {subject}:"
         for variable in undefined:
-            msg += f' {variable},'
+            msg += f" {variable},"
         # Return the message, stripping the last comma from it
         return msg[:-1], False
 

decoder/decoder.py

@@ -17,32 +17,34 @@
 
 # The (built-in) schemas...
 # from the same directory as us.
-_JD_SCHEMA_FILE: str = os.path.join(os.path.dirname(__file__),
-                                    'job-definition-schema.yaml')
-_MANIFEST_SCHEMA_FILE: str = os.path.join(os.path.dirname(__file__),
-                                          'manifest-schema.yaml')
+_JD_SCHEMA_FILE: str = os.path.join(
+    os.path.dirname(__file__), "job-definition-schema.yaml"
+)
+_MANIFEST_SCHEMA_FILE: str = os.path.join(
+    os.path.dirname(__file__), "manifest-schema.yaml"
+)
 
 # Load the JD schema YAML file now.
 # This must work as the file is installed along with this module.
 assert os.path.isfile(_JD_SCHEMA_FILE)
-with open(_JD_SCHEMA_FILE, 'r', encoding='utf8') as schema_file:
-    _JOB_DEFINITION_SCHEMA: Dict[str, Any] =\
-        yaml.load(schema_file, Loader=yaml.FullLoader)
+with open(_JD_SCHEMA_FILE, "r", encoding="utf8") as schema_file:
+    _JOB_DEFINITION_SCHEMA: Dict[str, Any] = yaml.load(
+        schema_file, Loader=yaml.FullLoader
+    )
 assert _JOB_DEFINITION_SCHEMA
 
 # Load the Manifest schema YAML file now.
 # This must work as the file is installed along with this module.
 assert os.path.isfile(_MANIFEST_SCHEMA_FILE)
-with open(_MANIFEST_SCHEMA_FILE, 'r', encoding='utf8') as schema_file:
-    _MANIFEST_SCHEMA: Dict[str, Any] =\
-        yaml.load(schema_file, Loader=yaml.FullLoader)
+with open(_MANIFEST_SCHEMA_FILE, "r", encoding="utf8") as schema_file:
+    _MANIFEST_SCHEMA: Dict[str, Any] = yaml.load(schema_file, Loader=yaml.FullLoader)
 assert _MANIFEST_SCHEMA
 
 
 class TextEncoding(enum.Enum):
-    """A general text encoding format, used initially for Job text fields.
-    """
-    JINJA2_3_0 = 1      # Encoding that complies with Jinja2 v3.0.x
+    """A general text encoding format, used initially for Job text fields."""
+
+    JINJA2_3_0 = 1  # Encoding that complies with Jinja2 v3.0.x
 
 
 def validate_manifest_schema(manifest: Dict[str, Any]) -> Optional[str]:
@@ -79,10 +81,12 @@ def validate_job_schema(job_definition: Dict[str, Any]) -> Optional[str]:
     return None
 
 
-def decode(template_text: str,
-           variable_map: Optional[Dict[str, str]],
-           subject: str,
-           template_engine: TextEncoding) -> Tuple[str, bool]:
+def decode(
+    template_text: str,
+    variable_map: Optional[Dict[str, str]],
+    subject: str,
+    template_engine: TextEncoding,
+) -> Tuple[str, bool]:
     """Given some text and a 'variable map' (a dictionary of keys and values)
     this returns the decoded text (using the named engine) as a string
     and a boolean set to True. On failure the boolean is False and the returned
@@ -101,8 +105,8 @@ def decode(template_text: str,
     if variable_map is None:
         return template_text, True
 
-    if template_engine.name.lower() == 'jinja2_3_0':
+    if template_engine.name.lower() == "jinja2_3_0":
         return decode_jinja2_3_0.decode(template_text, variable_map, subject)
 
     # Unsupported engine if we get here!
-    return f'Unsupported template engine: {template_engine}', False
+    return f"Unsupported template engine: {template_engine}", False

tests/test_decode_jinja2_3_0.py

@@ -1,5 +1,6 @@
 # Tests for the decoder package.
 import pytest
+
 pytestmark = pytest.mark.unit
 
 from typing import Dict
@@ -9,12 +10,12 @@
 
 def test_basic_decode():
     # Arrange
-    text: str = 'foo={{ foo }}, bar={{ bar }}, baz={{ baz }}'
-    field_map: Dict = {'foo': 1, 'bar': 2, 'baz': 3}
-    expected_text: str = 'foo=1, bar=2, baz=3'
+    text: str = "foo={{ foo }}, bar={{ bar }}, baz={{ baz }}"
+    field_map: Dict = {"foo": 1, "bar": 2, "baz": 3}
+    expected_text: str = "foo=1, bar=2, baz=3"
 
     # Act
-    rendered, success = decode_jinja2_3_0.decode(text, field_map, 'text')
+    rendered, success = decode_jinja2_3_0.decode(text, field_map, "text")
 
     # Assert
     assert success
@@ -23,31 +24,33 @@ def test_basic_decode():
 
 def test_decode_with_missing_variables():
     # Arrange
-    text: str = 'foo={{ foo }}, bar={{ bar }}, baz={{ baz }}'
-    field_map: Dict = {'foo': 1}
-    expected_text_prefix: str = 'Undefined template variables for text:'
+    text: str = "foo={{ foo }}, bar={{ bar }}, baz={{ baz }}"
+    field_map: Dict = {"foo": 1}
+    expected_text_prefix: str = "Undefined template variables for text:"
 
     # Act
-    rendered, success = decode_jinja2_3_0.decode(text, field_map, 'text')
+    rendered, success = decode_jinja2_3_0.decode(text, field_map, "text")
 
     # Assert
     assert not success
     # The order of missing variables is not deterministic.
     # They change - so we just need to make suer they're there.
     assert rendered.startswith(expected_text_prefix)
-    assert 'bar' in rendered
-    assert 'baz' in rendered
+    assert "bar" in rendered
+    assert "baz" in rendered
 
 
 def test_decode_with_template_error():
     # Arrange
-    text: str = 'foo={{ foo doo }}, bar={{ bar }}, baz={{ baz }}'
-    field_map: Dict = {'foo': 1}
-    expected_text: str = "TemplateSyntaxError with text:" \
-                         " expected token 'end of print statement', got 'doo'"
+    text: str = "foo={{ foo doo }}, bar={{ bar }}, baz={{ baz }}"
+    field_map: Dict = {"foo": 1}
+    expected_text: str = (
+        "TemplateSyntaxError with text:"
+        " expected token 'end of print statement', got 'doo'"
+    )
 
     # Act
-    rendered, success = decode_jinja2_3_0.decode(text, field_map, 'text')
+    rendered, success = decode_jinja2_3_0.decode(text, field_map, "text")
 
     # Assert
     assert not success

tests/test_decoder.py

@@ -2,20 +2,22 @@
 from typing import Dict
 
 import pytest
+
 pytestmark = pytest.mark.unit
 
 from decoder import decoder
 
 
 def test_jinja2_3_0_decode():
     # Arrange
-    text: str = 'foo={{ foo }}, bar={{ bar }}, baz={{ baz }}'
-    field_map: Dict = {'foo': 1, 'bar': 2, 'baz': 3}
-    expected_text: str = 'foo=1, bar=2, baz=3'
+    text: str = "foo={{ foo }}, bar={{ bar }}, baz={{ baz }}"
+    field_map: Dict = {"foo": 1, "bar": 2, "baz": 3}
+    expected_text: str = "foo=1, bar=2, baz=3"
 
     # Act
-    rendered, success = decoder.decode(text, field_map, 'text',
-                                       decoder.TextEncoding.JINJA2_3_0)
+    rendered, success = decoder.decode(
+        text, field_map, "text", decoder.TextEncoding.JINJA2_3_0
+    )
 
     # Assert
     assert success
@@ -24,26 +26,28 @@ def test_jinja2_3_0_decode():
 
 def test_jinja2_3_0_decode_with_missing_variables():
     # Arrange
-    text: str = 'foo={{ foo }}, bar={{ bar }}, baz={{ baz }}'
-    field_map: Dict = {'foo': 1, 'bar': 2}
+    text: str = "foo={{ foo }}, bar={{ bar }}, baz={{ baz }}"
+    field_map: Dict = {"foo": 1, "bar": 2}
 
     # Act
-    rendered, success = decoder.decode(text, field_map, 'text',
-                                       decoder.TextEncoding.JINJA2_3_0)
+    rendered, success = decoder.decode(
+        text, field_map, "text", decoder.TextEncoding.JINJA2_3_0
+    )
 
     # Assert
     assert not success
-    assert rendered == 'Undefined template variables for text: baz'
+    assert rendered == "Undefined template variables for text: baz"
 
 
 def test_jinja2_3_0_decode_without_variables():
     # Arrange
-    text: str = 'foo=1, bar=2, baz=3'
-    expected_text: str = 'foo=1, bar=2, baz=3'
+    text: str = "foo=1, bar=2, baz=3"
+    expected_text: str = "foo=1, bar=2, baz=3"
 
     # Act
-    rendered, success = decoder.decode(text, None, 'text',
-                                       decoder.TextEncoding.JINJA2_3_0)
+    rendered, success = decoder.decode(
+        text, None, "text", decoder.TextEncoding.JINJA2_3_0
+    )
 
     # Assert
     assert success