python-hcl2 7.0.1__tar.gz → 7.2.0__tar.gz

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## \[Unreleased\]
+
+- Nothing Yet
+
+## \[7.2.0\] - 2025-04-24
+
+### Added
+
+- Possibility to parse deeply nested interpolations (formerly a Limitation), Thanks again, @weaversam8 ([#223](https://github.com/amplify-education/python-hcl2/pull/223))
+
+### Fixed
+
+- Issue parsing ellipsis in a separate line within `for` expression ([#221](https://github.com/amplify-education/python-hcl2/pull/221))
+- Issue parsing inline expression as an object key; **see Limitations in README.md** ([#222](https://github.com/amplify-education/python-hcl2/pull/222))
+- Preserve literals of e-notation floats in parsing and reconstruction. Thanks, @eranor ([#226](https://github.com/amplify-education/python-hcl2/pull/226))
+
+## \[7.1.0\] - 2025-04-10
+
+### Added
+
+- `hcl2.builder.Builder` - nested blocks support ([#214](https://github.com/amplify-education/python-hcl2/pull/214))
+
+### Fixed
+
+- Issue parsing parenthesesed identifier (reference) as an object key ([#212](https://github.com/amplify-education/python-hcl2/pull/212))
+- Issue discarding empty lists when transforming python dictionary into Lark Tree ([#216](https://github.com/amplify-education/python-hcl2/pull/216))
+
 ## \[7.0.1\] - 2025-03-31
 
 ### Fixed

{python_hcl2-7.0.1/python_hcl2.egg-info → python_hcl2-7.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hcl2
-Version: 7.0.1
+Version: 7.2.0
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -114,20 +114,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/README.md

@@ -87,20 +87,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```

python_hcl2-7.2.0/hcl2/builder.py

@@ -0,0 +1,86 @@
+"""A utility class for constructing HCL documents from Python code."""
+from typing import List, Optional
+
+from collections import defaultdict
+
+from hcl2.const import START_LINE_KEY, END_LINE_KEY
+
+
+class Builder:
+    """
+    The `hcl2.Builder` class produces a dictionary that should be identical to the
+    output of `hcl2.load(example_file, with_meta=True)`. The `with_meta` keyword
+    argument is important here. HCL "blocks" in the Python dictionary are
+    identified by the presence of `__start_line__` and `__end_line__` metadata
+    within them. The `Builder` class handles adding that metadata. If that metadata
+    is missing, the `hcl2.reconstructor.HCLReverseTransformer` class fails to
+    identify what is a block and what is just an attribute with an object value.
+    """
+
+    def __init__(self, attributes: Optional[dict] = None):
+        self.blocks: dict = defaultdict(list)
+        self.attributes = attributes or {}
+
+    def block(
+        self,
+        block_type: str,
+        labels: Optional[List[str]] = None,
+        __nested_builder__: Optional["Builder"] = None,
+        **attributes
+    ) -> "Builder":
+        """Create a block within this HCL document."""
+
+        if __nested_builder__ is self:
+            raise ValueError(
+                "__nested__builder__ cannot be the same instance as instance this method is called on"
+            )
+
+        labels = labels or []
+        block = Builder(attributes)
+
+        # store the block in the document
+        self.blocks[block_type].append((labels.copy(), block, __nested_builder__))
+
+        return block
+
+    def build(self):
+        """Return the Python dictionary for this HCL document."""
+        body = defaultdict(list)
+
+        body.update(
+            {
+                START_LINE_KEY: -1,
+                END_LINE_KEY: -1,
+                **self.attributes,
+            }
+        )
+
+        for block_type, blocks in self.blocks.items():
+
+            for labels, block_builder, nested_blocks in blocks:
+                # build the sub-block
+                block = block_builder.build()
+
+                if nested_blocks:
+                    self._add_nested_blocks(block, nested_blocks)
+
+                # apply any labels
+                for label in reversed(labels):
+                    block = {label: block}
+
+                # store it in the body
+                body[block_type].append(block)
+
+        return body
+
+    def _add_nested_blocks(
+        self, block: dict, nested_blocks_builder: "Builder"
+    ) -> "dict":
+        """Add nested blocks defined within another `Builder` instance to the `block` dictionary"""
+        nested_block = nested_blocks_builder.build()
+        for key, value in nested_block.items():
+            if key not in (START_LINE_KEY, END_LINE_KEY):
+                if key not in block.keys():
+                    block[key] = []
+                block[key].extend(value)
+        return block

python_hcl2-7.2.0/hcl2/const.py

@@ -0,0 +1,4 @@
+"""Module for various constants used across the library"""
+
+START_LINE_KEY = "__start_line__"
+END_LINE_KEY = "__end_line__"

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/hcl2/hcl2.lark

@@ -1,7 +1,7 @@
 start : body
 body : (new_line_or_comment? (attribute | block))* new_line_or_comment?
 attribute : identifier EQ expression
-block : identifier (identifier | STRING_LIT)* new_line_or_comment? "{" body "}"
+block : identifier (identifier | STRING_LIT | string_with_interpolation)* new_line_or_comment? "{" body "}"
 new_line_or_comment: ( NL_OR_COMMENT )+
 NL_OR_COMMENT: /\n[ \t]*/ | /#.*\n/ | /\/\/.*\n/ | /\/\*(.|\n)*?(\*\/)/
 
@@ -39,11 +39,13 @@ LPAR : "("
 RPAR : ")"
 COMMA : ","
 DOT : "."
+COLON : ":"
 
 expr_term : LPAR new_line_or_comment? expression new_line_or_comment? RPAR
             | float_lit
             | int_lit
             | STRING_LIT
+            | string_with_interpolation
             | tuple
             | object
             | function_call
@@ -58,10 +60,10 @@ expr_term : LPAR new_line_or_comment? expression new_line_or_comment? RPAR
             | for_tuple_expr
             | for_object_expr
 
-STRING_LIT : "\"" (STRING_CHARS | INTERPOLATION)* "\""
-STRING_CHARS : /(?:(?!\${)([^"\\]|\\.))+/+ // any character except '"" unless inside a interpolation string
-NESTED_INTERPOLATION : "${" /[^}]+/ "}"
-INTERPOLATION : "${" (/(?:(?!\${)([^}]))+/ | NESTED_INTERPOLATION)+ "}"
+STRING_LIT : "\"" STRING_CHARS? "\""
+STRING_CHARS : /(?:(?!\${)([^"\\]|\\.|\$\$))+/ // any character except '"', including escaped $$
+string_with_interpolation: "\"" (STRING_CHARS)* interpolation_maybe_nested (STRING_CHARS | interpolation_maybe_nested)* "\""
+interpolation_maybe_nested: "${" expression "}"
 
 
 int_lit : NEGATIVE_DECIMAL? DECIMAL+ | NEGATIVE_DECIMAL+
@@ -74,8 +76,9 @@ EQ : /[ \t]*=(?!=|>)/
 
 tuple : "[" (new_line_or_comment* expression new_line_or_comment* ",")* (new_line_or_comment* expression)? new_line_or_comment* "]"
 object : "{" new_line_or_comment? (new_line_or_comment* (object_elem | (object_elem COMMA)) new_line_or_comment*)* "}"
-object_elem : object_elem_key ( EQ | ":") expression
-object_elem_key : float_lit | int_lit | identifier | STRING_LIT | object_elem_key_dot_accessor
+object_elem : object_elem_key ( EQ | COLON ) expression
+object_elem_key : float_lit | int_lit | identifier | STRING_LIT | object_elem_key_dot_accessor | object_elem_key_expression
+object_elem_key_expression : LPAR expression RPAR
 object_elem_key_dot_accessor : identifier (DOT identifier)+
 
 heredoc_template : /<<(?P<heredoc>[a-zA-Z][a-zA-Z0-9._-]+)\n?(?:.|\n)*?\n\s*(?P=heredoc)\n/
@@ -97,7 +100,7 @@ full_splat : "[*]" (get_attr | index)*
 
 FOR_OBJECT_ARROW : "=>"
 !for_tuple_expr : "[" new_line_or_comment? for_intro new_line_or_comment? expression new_line_or_comment? for_cond? new_line_or_comment? "]"
-!for_object_expr : "{" new_line_or_comment? for_intro new_line_or_comment? expression FOR_OBJECT_ARROW new_line_or_comment? expression "..."? new_line_or_comment? for_cond? new_line_or_comment? "}"
+!for_object_expr : "{" new_line_or_comment? for_intro new_line_or_comment? expression FOR_OBJECT_ARROW new_line_or_comment? expression new_line_or_comment? "..."? new_line_or_comment? for_cond? new_line_or_comment? "}"
 !for_intro : "for" new_line_or_comment? identifier ("," identifier new_line_or_comment?)? new_line_or_comment? "in" new_line_or_comment? expression new_line_or_comment? ":" new_line_or_comment?
 !for_cond : "if" new_line_or_comment? expression
 

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/hcl2/reconstructor.py

@@ -10,6 +10,8 @@ from lark.lexer import Token, PatternStr, TerminalDef
 from lark.reconstruct import Reconstructor
 from lark.tree_matcher import is_discarded_terminal
 from lark.visitors import Transformer_InPlace
+
+from hcl2.const import START_LINE_KEY, END_LINE_KEY
 from hcl2.parser import reconstruction_parser
 
 
@@ -258,6 +260,7 @@ class HCLReconstructor(Reconstructor):
                 Terminal("STRING_LIT"),
                 Terminal("DECIMAL"),
                 Terminal("NAME"),
+                Terminal("NEGATIVE_DECIMAL"),
             ]:
                 return True
 
@@ -395,46 +398,38 @@ class HCLReverseTransformer:
 
         return True
 
+    @classmethod
+    def _unwrap_interpolation(cls, value: str) -> str:
+        if cls._is_string_wrapped_tf(value):
+            return value[2:-1]
+        return value
+
     def _newline(self, level: int, count: int = 1) -> Tree:
         return Tree(
             Token("RULE", "new_line_or_comment"),
             [Token("NL_OR_COMMENT", f"\n{'  ' * level}") for _ in range(count)],
         )
 
-    # rules: the value of a block is always an array of dicts,
-    # the key is the block type
-    def _list_is_a_block(self, value: list) -> bool:
-        for obj in value:
-            if not self._dict_is_a_block(obj):
-                return False
-
-        return True
-
-    def _dict_is_a_block(self, sub_obj: Any) -> bool:
-        # if the list doesn't contain dictionaries, it's not a block
-        if not isinstance(sub_obj, dict):
-            return False
+    def _is_block(self, value: Any) -> bool:
+        if isinstance(value, dict):
+            block_body = value
+            if START_LINE_KEY in block_body.keys() or END_LINE_KEY in block_body.keys():
+                return True
 
-        # if the sub object has "start_line" and "end_line" metadata,
-        # the block itself is unlabeled, but it is a block
-        if "__start_line__" in sub_obj.keys() or "__end_line__" in sub_obj.keys():
-            return True
+            try:
+                # if block is labeled, actual body might be nested
+                # pylint: disable=W0612
+                block_label, block_body = next(iter(value.items()))
+            except StopIteration:
+                # no more potential labels = nothing more to check
+                return False
 
-        # if the objects in the array have no metadata and more than 2 keys and
-        # no metadata, it's just an array of objects, not a block
-        if len(list(sub_obj)) != 1:
-            return False
+            return self._is_block(block_body)
 
-        # if the sub object has a single string key whose value is an object,
-        # it _could_ be a labeled block... but we'd have to check if the sub
-        # object is a block (recurse)
-        label = list(sub_obj)[0]
-        sub_sub_obj = sub_obj[label]
-        if self._dict_is_a_block(sub_sub_obj):
-            return True
+        if isinstance(value, list):
+            if len(value) > 0:
+                return self._is_block(value[0])
 
-        # if the objects in the array have a single key whose child is not a
-        # block, the array is just an array of objects, not a block
         return False
 
     def _calculate_block_labels(self, block: dict) -> Tuple[List[str], dict]:
@@ -448,8 +443,8 @@ class HCLReverseTransformer:
 
         # __start_line__ and __end_line__ metadata are not labels
         if (
-            "__start_line__" in potential_body.keys()
-            or "__end_line__" in potential_body.keys()
+            START_LINE_KEY in potential_body.keys()
+            or END_LINE_KEY in potential_body.keys()
         ):
             return [curr_label], potential_body
 
@@ -457,6 +452,7 @@ class HCLReverseTransformer:
         next_label, block_body = self._calculate_block_labels(potential_body)
         return [curr_label] + next_label, block_body
 
+    # pylint:disable=R0914
     def _transform_dict_to_body(self, hcl_dict: dict, level: int) -> Tree:
         # we add a newline at the top of a body within a block, not the root body
         # >2 here is to ignore the __start_line__ and __end_line__ metadata
@@ -467,14 +463,14 @@ class HCLReverseTransformer:
 
         # iterate through each attribute or sub-block of this block
         for key, value in hcl_dict.items():
-            if key in ["__start_line__", "__end_line__"]:
+            if key in [START_LINE_KEY, END_LINE_KEY]:
                 continue
 
             # construct the identifier, whether that be a block type name or an attribute key
             identifier_name = self._name_to_identifier(key)
 
             # first, check whether the value is a "block"
-            if isinstance(value, list) and self._list_is_a_block(value):
+            if self._is_block(value):
                 for block_v in value:
                     block_labels, block_body_dict = self._calculate_block_labels(
                         block_v
@@ -493,7 +489,12 @@ class HCLReverseTransformer:
                         [identifier_name] + block_label_tokens + [block_body],
                     )
                     children.append(block)
-                    children.append(self._newline(level, count=2))
+                    # add empty line after block
+                    new_line = self._newline(level - 1)
+                    # add empty line with indentation for next element in the block
+                    new_line.children.append(self._newline(level).children[0])
+
+                    children.append(new_line)
 
             # if the value isn't a block, it's an attribute
             else:
@@ -517,7 +518,7 @@ class HCLReverseTransformer:
 
         return Tree(Token("RULE", "body"), children)
 
-    # pylint: disable=too-many-branches, too-many-return-statements
+    # pylint: disable=too-many-branches, too-many-return-statements too-many-statements
     def _transform_value_to_expr_term(self, value, level) -> Union[Token, Tree]:
         """Transforms a value from a dictionary into an "expr_term" (a value in HCL2)
 
@@ -556,10 +557,11 @@ class HCLReverseTransformer:
 
             # iterate through the items and add them to the object
             for i, (k, dict_v) in enumerate(value.items()):
-                if k in ["__start_line__", "__end_line__"]:
+                if k in [START_LINE_KEY, END_LINE_KEY]:
                     continue
 
                 value_expr_term = self._transform_value_to_expr_term(dict_v, level + 1)
+                k = self._unwrap_interpolation(k)
                 elements.append(
                     Tree(
                         Token("RULE", "object_elem"),
@@ -607,6 +609,37 @@ class HCLReverseTransformer:
                 ],
             )
 
+        if isinstance(value, float):
+            value = str(value)
+            literal = []
+
+            if value[0] == "-":
+                # pop two first chars - minus and a digit
+                literal.append(Token("NEGATIVE_DECIMAL", value[:2]))
+                value = value[2:]
+
+            while value != "":
+                char = value[0]
+
+                if char == ".":
+                    # current char marks beginning of decimal part: pop all remaining chars and end the loop
+                    literal.append(Token("DOT", char))
+                    literal.extend(Token("DECIMAL", char) for char in value[1:])
+                    break
+
+                if char == "e":
+                    # current char marks beginning of e-notation: pop all remaining chars and end the loop
+                    literal.append(Token("EXP_MARK", value))
+                    break
+
+                literal.append(Token("DECIMAL", char))
+                value = value[1:]
+
+            return Tree(
+                Token("RULE", "expr_term"),
+                [Tree(Token("RULE", "float_lit"), literal)],
+            )
+
         # store strings as single literals
         if isinstance(value, str):
             # potentially unpack a complex syntax structure

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/hcl2/transformer.py

@@ -44,7 +44,10 @@ class DictTransformer(Transformer):
         super().__init__()
 
     def float_lit(self, args: List) -> float:
-        return float("".join([self.to_tf_inline(arg) for arg in args]))
+        value = "".join([self.to_tf_inline(arg) for arg in args])
+        if "e" in value:
+            return self.to_string_dollar(value)
+        return float(value)
 
     def int_lit(self, args: List) -> int:
         return int("".join([self.to_tf_inline(arg) for arg in args]))
@@ -98,11 +101,9 @@ class DictTransformer(Transformer):
     def object_elem(self, args: List) -> Dict:
         # This returns a dict with a single key/value pair to make it easier to merge these
         # into a bigger dict that is returned by the "object" function
+
         key = self.strip_quotes(str(args[0].children[0]))
-        if len(args) == 3:
-            value = args[2]
-        else:
-            value = args[1]
+        value = args[2]
 
         value = self.to_string_dollar(value)
         return {key: value}
@@ -110,6 +111,9 @@ class DictTransformer(Transformer):
     def object_elem_key_dot_accessor(self, args: List) -> str:
         return "".join(args)
 
+    def object_elem_key_expression(self, args: List) -> str:
+        return self.to_string_dollar("".join(args))
+
     def object(self, args: List) -> Dict:
         args = self.strip_new_line_tokens(args)
         result: Dict[str, Any] = {}
@@ -176,7 +180,9 @@ class DictTransformer(Transformer):
         return f"{args[0]} ? {args[1]} : {args[2]}"
 
     def binary_op(self, args: List) -> str:
-        return " ".join([self.to_tf_inline(arg) for arg in args])
+        return " ".join(
+            [self.unwrap_string_dollar(self.to_tf_inline(arg)) for arg in args]
+        )
 
     def unary_op(self, args: List) -> str:
         args = self.process_nulls(args)
@@ -303,21 +309,31 @@ class DictTransformer(Transformer):
         """
         return [arg for arg in args if arg != "\n" and arg is not Discard]
 
+    def is_string_dollar(self, value: str) -> bool:
+        if not isinstance(value, str):
+            return False
+        return value.startswith("${") and value.endswith("}")
+
     def to_string_dollar(self, value: Any) -> Any:
         """Wrap a string in ${ and }"""
-        if isinstance(value, str):
+        if not isinstance(value, str):
+            return value
             # if it's already wrapped, pass it unmodified
-            if value.startswith("${") and value.endswith("}"):
-                return value
+        if self.is_string_dollar(value):
+            return value
 
-            if value.startswith('"') and value.endswith('"'):
-                value = str(value)[1:-1]
-                return self.process_escape_sequences(value)
+        if value.startswith('"') and value.endswith('"'):
+            value = str(value)[1:-1]
+            return self.process_escape_sequences(value)
+
+        if self.is_type_keyword(value):
+            return value
 
-            if self.is_type_keyword(value):
-                return value
+        return f"${{{value}}}"
 
-            return f"${{{value}}}"
+    def unwrap_string_dollar(self, value: str):
+        if self.is_string_dollar(value):
+            return value[2:-1]
         return value
 
     def strip_quotes(self, value: Any) -> Any:

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/hcl2/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '7.0.1'
-__version_tuple__ = version_tuple = (7, 0, 1)
+__version__ = version = '7.2.0'
+__version_tuple__ = version_tuple = (7, 2, 0)

{python_hcl2-7.0.1 → python_hcl2-7.2.0/python_hcl2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hcl2
-Version: 7.0.1
+Version: 7.2.0
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -114,20 +114,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```

{python_hcl2-7.0.1 → python_hcl2-7.2.0}/python_hcl2.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ hcl2/__init__.py
 hcl2/__main__.py
 hcl2/api.py
 hcl2/builder.py
+hcl2/const.py
 hcl2/hcl2.lark
 hcl2/parser.py
 hcl2/py.typed

python_hcl2-7.0.1/hcl2/builder.py

@@ -1,63 +0,0 @@
-"""A utility class for constructing HCL documents from Python code."""
-
-from typing import List, Optional
-
-
-class Builder:
-    """
-    The `hcl2.Builder` class produces a dictionary that should be identical to the
-    output of `hcl2.load(example_file, with_meta=True)`. The `with_meta` keyword
-    argument is important here. HCL "blocks" in the Python dictionary are
-    identified by the presence of `__start_line__` and `__end_line__` metadata
-    within them. The `Builder` class handles adding that metadata. If that metadata
-    is missing, the `hcl2.reconstructor.HCLReverseTransformer` class fails to
-    identify what is a block and what is just an attribute with an object value.
-    """
-
-    def __init__(self, attributes: Optional[dict] = None):
-        self.blocks: dict = {}
-        self.attributes = attributes or {}
-
-    def block(
-        self, block_type: str, labels: Optional[List[str]] = None, **attributes
-    ) -> "Builder":
-        """Create a block within this HCL document."""
-        labels = labels or []
-        block = Builder(attributes)
-
-        # initialize a holder for blocks of that type
-        if block_type not in self.blocks:
-            self.blocks[block_type] = []
-
-        # store the block in the document
-        self.blocks[block_type].append((labels.copy(), block))
-
-        return block
-
-    def build(self):
-        """Return the Python dictionary for this HCL document."""
-        body = {
-            "__start_line__": -1,
-            "__end_line__": -1,
-            **self.attributes,
-        }
-
-        for block_type, blocks in self.blocks.items():
-
-            # initialize a holder for blocks of that type
-            if block_type not in body:
-                body[block_type] = []
-
-            for labels, block_builder in blocks:
-                # build the sub-block
-                block = block_builder.build()
-
-                # apply any labels
-                labels.reverse()
-                for label in labels:
-                    block = {label: block}
-
-                # store it in the body
-                body[block_type].append(block)
-
-        return body