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

python_hcl2-7.0.1/.github/ISSUE_TEMPLATE/hcl2-parsing-error.md

@@ -0,0 +1,32 @@
+---
+name: HCL2 parsing error
+about: Template for reporting a bug related to parsing HCL2 code
+title: ''
+labels: bug
+assignees: kkozik-amplify
+
+---
+
+**Describe the bug**
+
+A clear and concise description of what the bug is.
+
+**Software:**
+ - OS: [macOS / Windows / Linux]
+ - Python version (e.g. 3.9.21)
+ - python-hcl2 version (e.g. 7.0.0)
+
+**Snippet of HCL2 code causing the unexpected behaviour:**
+```terraform
+locals {
+  foo = "bar"
+}
+```
+**Expected behavior**
+
+A clear and concise description of what you expected to happen, e.g. python dictionary or JSON you expected to receive as a result of parsing.
+
+**Exception traceback (if applicable)**:
+
+```
+```

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/.github/workflows/publish.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v2
         with:
-          python-version: 3.7
+          python-version: 3.13
       - name: Install dependencies
         run: python -m pip install --upgrade pip build
       - name: Generate Lark Parser
@@ -23,12 +23,12 @@ jobs:
       - name: Build tarball
         run: python3 -m build
       - name: Publish to Test PyPI
-        uses: pypa/gh-action-pypi-publish@master
+        uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.TEST_PYPI_API_TOKEN }}
           repository_url: https://test.pypi.org/legacy/
           skip_existing: true
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@master
+        uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/CHANGELOG.md

@@ -5,6 +5,32 @@ 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).
 
+## \[7.0.1\] - 2025-03-31
+
+### Fixed
+
+- Issue parsing dot-accessed attribute as an object key ([#209](https://github.com/amplify-education/python-hcl2/pull/209))
+
+## \[7.0.0\] - 2025-03-27
+
+### Added
+
+- `Limitations` section to README.md ([#200](https://github.com/amplify-education/python-hcl2/pull/200))
+
+### Fixed
+
+- Issue handling heredoc with delimiter within text itself ([#194](https://github.com/amplify-education/python-hcl2/pull/194))
+- Various issues with parsing object elements ([#197](https://github.com/amplify-education/python-hcl2/pull/197))
+- Dictionary -> hcl2 reconstruction of `null` values ([#198](https://github.com/amplify-education/python-hcl2/pull/198))
+- Inaccurate parsing of `null` values in some cases ([#206](https://github.com/amplify-education/python-hcl2/pull/206))
+- Missing parenthesis in arithemetic expressions ([#194](https://github.com/amplify-education/python-hcl2/pull/199))
+- Noticeable overhead when loading hcl2.reconstructor module ([#202](https://github.com/amplify-education/python-hcl2/pull/202))
+- Escaped string interpolation (e.g. `"$${aws:username}"`) parsing ([#200](https://github.com/amplify-education/python-hcl2/pull/200))
+
+### Removed
+
+- Support for parsing interpolations nested more than 2 times (known-issue) ([#200](https://github.com/amplify-education/python-hcl2/pull/200))
+
 ## \[6.1.1\] - 2025-02-13
 
 ### Fixed

{python-hcl2-6.1.1/python_hcl2.egg-info → python_hcl2-7.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-hcl2
-Version: 6.1.1
+Version: 7.0.1
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -22,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.7.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: lark<2,>=1
+Dynamic: license-file
 
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/2e2015f9297346cbaa788c46ab957827)](https://app.codacy.com/gh/amplify-education/python-hcl2/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![Build Status](https://travis-ci.org/amplify-education/python-hcl2.svg?branch=master)](https://travis-ci.org/amplify-education/python-hcl2)
@@ -92,7 +94,7 @@ To see all the available options, run `tox -l`.
 
 ## Releasing
 
-To create a new releaes go to Releases page, press 'Draft a new release', create a tag
+To create a new release go to Releases page, press 'Draft a new release', create a tag
 with a version you want to be released, fill the release notes and press 'Publish release'.
 Github actions will take care of publishing it to PyPi.
 
@@ -109,3 +111,23 @@ We welcome pull requests! For your pull request to be accepted smoothly, we sugg
 - Create a pull request.  Explain why you want to make the change and what it’s for.
 
 We’ll try to answer any PR’s promptly.
+
+## Limitations
+
+### Error parsing string interpolations nested more than 2 times
+
+- Parsing following example is expected to throw out an exception and fail:
+  ```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"
+  }
+  ```

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/README.md

@@ -67,7 +67,7 @@ To see all the available options, run `tox -l`.
 
 ## Releasing
 
-To create a new releaes go to Releases page, press 'Draft a new release', create a tag
+To create a new release go to Releases page, press 'Draft a new release', create a tag
 with a version you want to be released, fill the release notes and press 'Publish release'.
 Github actions will take care of publishing it to PyPi.
 
@@ -84,3 +84,23 @@ We welcome pull requests! For your pull request to be accepted smoothly, we sugg
 - Create a pull request.  Explain why you want to make the change and what it’s for.
 
 We’ll try to answer any PR’s promptly.
+
+## Limitations
+
+### Error parsing string interpolations nested more than 2 times
+
+- Parsing following example is expected to throw out an exception and fail:
+  ```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"
+  }
+  ```

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/hcl2/__init__.py

@@ -13,7 +13,6 @@ from .api import (
     transform,
     reverse_transform,
     writes,
-    AST,
 )
 
 from .builder import Builder

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/hcl2/api.py

@@ -1,9 +1,10 @@
 """The API that will be exposed to users of this package"""
 from typing import TextIO
 
-from lark.tree import Tree as AST
-from hcl2.parser import parser
+from lark.tree import Tree
+from hcl2.parser import parser, reconstruction_parser
 from hcl2.transformer import DictTransformer
+from hcl2.reconstructor import HCLReconstructor, HCLReverseTransformer
 
 
 def load(file: TextIO, with_meta=False) -> dict:
@@ -22,61 +23,45 @@ def loads(text: str, with_meta=False) -> dict:
     parameters to the output dict. Default to false.
     """
     # append new line as a workaround for https://github.com/lark-parser/lark/issues/237
-    # Lark doesn't support a EOF token so our grammar can't look for "new line or end of file"
+    # Lark doesn't support EOF token so our grammar can't look for "new line or end of file"
     # This means that all blocks must end in a new line even if the file ends
     # Append a new line as a temporary fix
     tree = parser().parse(text + "\n")
     return DictTransformer(with_meta=with_meta).transform(tree)
 
 
-def parse(file: TextIO) -> AST:
+def parse(file: TextIO) -> Tree:
     """Load HCL2 syntax tree from a file.
     :param file: File with hcl2 to be loaded as a dict.
     """
     return parses(file.read())
 
 
-def parses(text: str) -> AST:
+def parses(text: str) -> Tree:
     """Load HCL2 syntax tree from a string.
     :param text: Text with hcl2 to be loaded as a dict.
     """
-    # defer this import until this method is called, due to the performance hit
-    # of rebuilding the grammar without cache
-    from hcl2.parser import (  # pylint: disable=import-outside-toplevel
-        reconstruction_parser,
-    )
-
     return reconstruction_parser().parse(text)
 
 
-def transform(ast: AST, with_meta=False) -> dict:
+def transform(ast: Tree, with_meta=False) -> dict:
     """Convert an HCL2 AST to a dictionary.
     :param ast: HCL2 syntax tree, output from `parse` or `parses`
+    :param with_meta: If set to true then adds `__start_line__` and `__end_line__`
+        parameters to the output dict. Default to false.
     """
     return DictTransformer(with_meta=with_meta).transform(ast)
 
 
-def reverse_transform(hcl2_dict: dict) -> AST:
+def reverse_transform(hcl2_dict: dict) -> Tree:
     """Convert a dictionary to an HCL2 AST.
-    :param dict: a dictionary produced by `load` or `transform`
+    :param hcl2_dict: a dictionary produced by `load` or `transform`
     """
-    # defer this import until this method is called, due to the performance hit
-    # of rebuilding the grammar without cache
-    from hcl2.reconstructor import (  # pylint: disable=import-outside-toplevel
-        hcl2_reverse_transformer,
-    )
+    return HCLReverseTransformer().transform(hcl2_dict)
 
-    return hcl2_reverse_transformer.transform(hcl2_dict)
 
-
-def writes(ast: AST) -> str:
+def writes(ast: Tree) -> str:
     """Convert an HCL2 syntax tree to a string.
     :param ast: HCL2 syntax tree, output from `parse` or `parses`
     """
-    # defer this import until this method is called, due to the performance hit
-    # of rebuilding the grammar without cache
-    from hcl2.reconstructor import (  # pylint: disable=import-outside-toplevel
-        hcl2_reconstructor,
-    )
-
-    return hcl2_reconstructor.reconstruct(ast)
+    return HCLReconstructor(reconstruction_parser()).reconstruct(ast)

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/hcl2/hcl2.lark

@@ -1,8 +1,7 @@
 start : body
 body : (new_line_or_comment? (attribute | block))* new_line_or_comment?
 attribute : identifier EQ expression
-block : identifier (identifier | STRING_LIT | string_with_interpolation)* new_line_or_comment? "{" body "}"
-new_line_and_or_comma: new_line_or_comment | "," | "," new_line_or_comment
+block : identifier (identifier | STRING_LIT)* new_line_or_comment? "{" body "}"
 new_line_or_comment: ( NL_OR_COMMENT )+
 NL_OR_COMMENT: /\n[ \t]*/ | /#.*\n/ | /\/\/.*\n/ | /\/\*(.|\n)*?(\*\/)/
 
@@ -36,12 +35,15 @@ PERCENT : "%"
 DOUBLE_AMP : "&&"
 DOUBLE_PIPE : "||"
 PLUS : "+"
+LPAR : "("
+RPAR : ")"
+COMMA : ","
+DOT : "."
 
-expr_term : "(" new_line_or_comment? expression new_line_or_comment? ")"
+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
@@ -56,10 +58,11 @@ expr_term : "(" new_line_or_comment? expression new_line_or_comment? ")"
             | for_tuple_expr
             | for_object_expr
 
-STRING_LIT : "\"" STRING_CHARS? "\""
-STRING_CHARS : /(?:(?!\${)([^"\\]|\\.))+/ // any character except '"'
-string_with_interpolation: "\"" (STRING_CHARS)* interpolation_maybe_nested (STRING_CHARS | interpolation_maybe_nested)* "\""
-interpolation_maybe_nested: "${" expression "}"
+STRING_LIT : "\"" (STRING_CHARS | INTERPOLATION)* "\""
+STRING_CHARS : /(?:(?!\${)([^"\\]|\\.))+/+ // any character except '"" unless inside a interpolation string
+NESTED_INTERPOLATION : "${" /[^}]+/ "}"
+INTERPOLATION : "${" (/(?:(?!\${)([^}]))+/ | NESTED_INTERPOLATION)+ "}"
+
 
 int_lit : NEGATIVE_DECIMAL? DECIMAL+ | NEGATIVE_DECIMAL+
 !float_lit: (NEGATIVE_DECIMAL? DECIMAL+ | NEGATIVE_DECIMAL+) "." DECIMAL+ (EXP_MARK)?
@@ -70,12 +73,13 @@ EXP_MARK : ("e" | "E") ("+" | "-")? DECIMAL+
 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? (object_elem (new_line_and_or_comma object_elem )* new_line_and_or_comma?)? "}"
-object_elem : (identifier | expression) ( EQ | ":") expression
-
+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_key_dot_accessor : identifier (DOT identifier)+
 
-heredoc_template : /<<(?P<heredoc>[a-zA-Z][a-zA-Z0-9._-]+)\n(?:.|\n)*?(?P=heredoc)/
-heredoc_template_trim : /<<-(?P<heredoc_trim>[a-zA-Z][a-zA-Z0-9._-]+)\n(?:.|\n)*?(?P=heredoc_trim)/
+heredoc_template : /<<(?P<heredoc>[a-zA-Z][a-zA-Z0-9._-]+)\n?(?:.|\n)*?\n\s*(?P=heredoc)\n/
+heredoc_template_trim : /<<-(?P<heredoc_trim>[a-zA-Z][a-zA-Z0-9._-]+)\n?(?:.|\n)*?\n\s*(?P=heredoc_trim)\n/
 
 function_call : identifier "(" new_line_or_comment? arguments? new_line_or_comment? ")"
 arguments : (expression (new_line_or_comment* "," new_line_or_comment*  expression)* ("," | "...")? new_line_or_comment*)

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/hcl2/reconstructor.py

@@ -22,7 +22,7 @@ def reverse_quotes_within_interpolation(interp_s: str) -> str:
     method removes any erroneous escapes within interpolated segments of a
     string.
     """
-    return re.sub(r"\$\{(.*)\}", lambda m: m.group(0).replace('\\"', '"'), interp_s)
+    return re.sub(r"\$\{(.*)}", lambda m: m.group(0).replace('\\"', '"'), interp_s)
 
 
 class WriteTokensAndMetaTransformer(Transformer_InPlace):
@@ -43,6 +43,7 @@ class WriteTokensAndMetaTransformer(Transformer_InPlace):
         tokens: Dict[str, TerminalDef],
         term_subs: Dict[str, Callable[[Symbol], str]],
     ) -> None:
+        super().__init__()
         self.tokens = tokens
         self.term_subs = term_subs
 
@@ -91,14 +92,6 @@ class WriteTokensAndMetaTransformer(Transformer_InPlace):
 class HCLReconstructor(Reconstructor):
     """This class converts a Lark.Tree AST back into a string representing the underlying HCL code."""
 
-    # these variables track state during reconstruction to enable us to make
-    # informed decisions about formatting output. They are primarily used
-    # by the _should_add_space(...) method.
-    last_char_space = True
-    last_terminal = None
-    last_rule = None
-    deferred_item = None
-
     def __init__(
         self,
         parser: Lark,
@@ -106,32 +99,38 @@ class HCLReconstructor(Reconstructor):
     ):
         Reconstructor.__init__(self, parser, term_subs)
 
-        self.write_tokens = WriteTokensAndMetaTransformer(
-            {token.name: token for token in self.tokens}, term_subs or {}
+        self.write_tokens: WriteTokensAndMetaTransformer = (
+            WriteTokensAndMetaTransformer(
+                {token.name: token for token in self.tokens}, term_subs or {}
+            )
         )
 
-    # space around these terminals if they're within for or if statements
-    FOR_IF_KEYWORDS = [
-        Terminal("IF"),
-        Terminal("IN"),
-        Terminal("FOR"),
-        Terminal("FOR_EACH"),
-        Terminal("FOR_OBJECT_ARROW"),
-        Terminal("COLON"),
-    ]
-
-    # space on both sides, in ternaries and binary operators
-    BINARY_OPS = [
-        Terminal("QMARK"),
-        Terminal("COLON"),
-        Terminal("BINARY_OP"),
-    ]
+        # these variables track state during reconstruction to enable us to make
+        # informed decisions about formatting output. They are primarily used
+        # by the _should_add_space(...) method.
+        self._last_char_space = True
+        self._last_terminal: Union[Terminal, None] = None
+        self._last_rule: Union[Tree, Token, None] = None
+        self._deferred_item = None
+
+    def should_be_wrapped_in_spaces(self, terminal: Terminal) -> bool:
+        """Whether given terminal should be wrapped in spaces"""
+        return terminal.name in {
+            "IF",
+            "IN",
+            "FOR",
+            "FOR_EACH",
+            "FOR_OBJECT_ARROW",
+            "COLON",
+            "QMARK",
+            "BINARY_OP",
+        }
 
     def _is_equals_sign(self, terminal) -> bool:
         return (
-            isinstance(self.last_rule, Token)
-            and self.last_rule.value in ("attribute", "object_elem")
-            and self.last_terminal == Terminal("EQ")
+            isinstance(self._last_rule, Token)
+            and self._last_rule.value in ("attribute", "object_elem")
+            and self._last_terminal == Terminal("EQ")
             and terminal != Terminal("NL_OR_COMMENT")
         )
 
@@ -155,11 +154,11 @@ class HCLReconstructor(Reconstructor):
         This should be sufficient to make a spacing decision.
         """
         # we don't need to add multiple spaces
-        if self.last_char_space:
+        if self._last_char_space:
             return False
 
         # we don't add a space at the start of the file
-        if not self.last_terminal or not self.last_rule:
+        if not self._last_terminal or not self._last_rule:
             return False
 
         if self._is_equals_sign(current_terminal):
@@ -173,20 +172,20 @@ class HCLReconstructor(Reconstructor):
                 "conditional",
                 "binary_operator",
             ]
-            and current_terminal in self.BINARY_OPS
+            and self.should_be_wrapped_in_spaces(current_terminal)
         ):
             return True
 
         # if we just left a ternary or binary operator, add space around the
         # operator unless there's a newline already
         if (
-            isinstance(self.last_rule, Token)
-            and self.last_rule.value
+            isinstance(self._last_rule, Token)
+            and self._last_rule.value
             in [
                 "conditional",
                 "binary_operator",
             ]
-            and self.last_terminal in self.BINARY_OPS
+            and self.should_be_wrapped_in_spaces(self._last_terminal)
             and current_terminal != Terminal("NL_OR_COMMENT")
         ):
             return True
@@ -200,21 +199,21 @@ class HCLReconstructor(Reconstructor):
                 "for_cond",
                 "for_intro",
             ]
-            and current_terminal in self.FOR_IF_KEYWORDS
+            and self.should_be_wrapped_in_spaces(current_terminal)
         ):
             return True
 
         # if we've just left a for or if statement and find a keyword, add a
         # space, unless we have a newline
         if (
-            isinstance(self.last_rule, Token)
-            and self.last_rule.value
+            isinstance(self._last_rule, Token)
+            and self._last_rule.value
             in [
                 "for_object_expr",
                 "for_cond",
                 "for_intro",
             ]
-            and self.last_terminal in self.FOR_IF_KEYWORDS
+            and self.should_be_wrapped_in_spaces(self._last_terminal)
             and current_terminal != Terminal("NL_OR_COMMENT")
         ):
             return True
@@ -230,7 +229,7 @@ class HCLReconstructor(Reconstructor):
             # always add space before the closing brace
             if current_terminal == Terminal(
                 "RBRACE"
-            ) and self.last_terminal != Terminal("LBRACE"):
+            ) and self._last_terminal != Terminal("LBRACE"):
                 return True
 
             # always add space between string literals
@@ -240,20 +239,20 @@ class HCLReconstructor(Reconstructor):
         # if we just opened a block, add a space, unless the block is empty
         # or has a newline
         if (
-            isinstance(self.last_rule, Token)
-            and self.last_rule.value == "block"
-            and self.last_terminal == Terminal("LBRACE")
+            isinstance(self._last_rule, Token)
+            and self._last_rule.value == "block"
+            and self._last_terminal == Terminal("LBRACE")
             and current_terminal not in [Terminal("RBRACE"), Terminal("NL_OR_COMMENT")]
         ):
             return True
 
         # if we're in a tuple or function arguments (this rule matches commas between items)
-        if isinstance(self.last_rule, str) and re.match(
-            r"^__(tuple|arguments)_(star|plus)_.*", self.last_rule
+        if isinstance(self._last_rule, str) and re.match(
+            r"^__(tuple|arguments)_(star|plus)_.*", self._last_rule
         ):
 
             # string literals, decimals, and identifiers should always be
-            # preceeded by a space if they're following a comma in a tuple or
+            # preceded by a space if they're following a comma in a tuple or
             # function arg
             if current_terminal in [
                 Terminal("STRING_LIT"),
@@ -279,12 +278,12 @@ class HCLReconstructor(Reconstructor):
                 rule, terminal, value = item
 
                 # first, handle any deferred items
-                if self.deferred_item is not None:
+                if self._deferred_item is not None:
                     (
                         deferred_rule,
                         deferred_terminal,
                         deferred_value,
-                    ) = self.deferred_item
+                    ) = self._deferred_item
 
                     # if we deferred a comma and the next character ends a
                     # parenthesis or block, we can throw it out
@@ -298,32 +297,32 @@ class HCLReconstructor(Reconstructor):
                         yield deferred_value
 
                         # and do our bookkeeping
-                        self.last_terminal = deferred_terminal
-                        self.last_rule = deferred_rule
+                        self._last_terminal = deferred_terminal
+                        self._last_rule = deferred_rule
                         if deferred_value and not deferred_value[-1].isspace():
-                            self.last_char_space = False
+                            self._last_char_space = False
 
                     # clear the deferred item
-                    self.deferred_item = None
+                    self._deferred_item = None
 
                 # potentially add a space before the next token
                 if self._should_add_space(rule, terminal):
                     yield " "
-                    self.last_char_space = True
+                    self._last_char_space = True
 
-                # potentially defer the item if needs to be
+                # potentially defer the item if needed
                 if terminal in [Terminal("COMMA")]:
-                    self.deferred_item = item
+                    self._deferred_item = item
                 else:
                     # otherwise print the next token
                     yield value
 
                     # and do our bookkeeping so we can make an informed
                     # decision about formatting next time
-                    self.last_terminal = terminal
-                    self.last_rule = rule
+                    self._last_terminal = terminal
+                    self._last_rule = rule
                     if value:
-                        self.last_char_space = value[-1].isspace()
+                        self._last_char_space = value[-1].isspace()
 
             else:
                 raise RuntimeError(f"Unknown bare token type: {item}")
@@ -375,7 +374,7 @@ class HCLReverseTransformer:
     @staticmethod
     def _is_string_wrapped_tf(interp_s: str) -> bool:
         """
-        Determines whether a string is a complex HCL datastructure
+        Determines whether a string is a complex HCL data structure
         wrapped in ${ interpolation } characters.
         """
         if not interp_s.startswith("${") or not interp_s.endswith("}"):
@@ -396,15 +395,7 @@ class HCLReverseTransformer:
 
         return True
 
-    def _newline(self, level: int, comma: bool = False, count: int = 1) -> Tree:
-        # some rules expect the `new_line_and_or_comma` token
-        if comma:
-            return Tree(
-                Token("RULE", "new_line_and_or_comma"),
-                [self._newline(level=level, comma=False, count=count)],
-            )
-
-        # otherwise, return the `new_line_or_comment` token
+    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)],
@@ -548,35 +539,48 @@ class HCLReverseTransformer:
             )
             return Tree(Token("RULE", "expr_term"), [tuple_tree])
 
+        if value is None:
+            return Tree(
+                Token("RULE", "expr_term"),
+                [Tree(Token("RULE", "identifier"), [Token("NAME", "null")])],
+            )
+
         # for dicts, recursively turn the child k/v pairs into object elements
         # and store within an object
         if isinstance(value, dict):
-            elems = []
+            elements = []
 
             # if the object has elements, put it on a newline
             if len(value) > 0:
-                elems.append(self._newline(level + 1))
+                elements.append(self._newline(level + 1))
 
             # 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__"]:
                     continue
-                identifier = self._name_to_identifier(k)
+
                 value_expr_term = self._transform_value_to_expr_term(dict_v, level + 1)
-                elems.append(
+                elements.append(
                     Tree(
                         Token("RULE", "object_elem"),
-                        [identifier, Token("EQ", " ="), value_expr_term],
+                        [
+                            Tree(
+                                Token("RULE", "object_elem_key"),
+                                [Tree(Token("RULE", "identifier"), [Token("NAME", k)])],
+                            ),
+                            Token("EQ", " ="),
+                            value_expr_term,
+                        ],
                     )
                 )
 
                 # add indentation appropriately
                 if i < len(value) - 1:
-                    elems.append(self._newline(level + 1, comma=True))
+                    elements.append(self._newline(level + 1))
                 else:
-                    elems.append(self._newline(level, comma=True))
+                    elements.append(self._newline(level))
             return Tree(
-                Token("RULE", "expr_term"), [Tree(Token("RULE", "object"), elems)]
+                Token("RULE", "expr_term"), [Tree(Token("RULE", "object"), elements)]
             )
 
         # treat booleans appropriately
@@ -626,12 +630,7 @@ class HCLReverseTransformer:
                     raise RuntimeError("Token must be `EQ (=)` rule")
 
                 parsed_value = attribute.children[2]
-
-                if parsed_value.data == Token("RULE", "expr_term"):
-                    return parsed_value
-
-                # wrap other types of syntax as an expression (in parenthesis)
-                return Tree(Token("RULE", "expr_term"), [parsed_value])
+                return parsed_value
 
             # otherwise it's just a string.
             return Tree(
@@ -641,7 +640,3 @@ class HCLReverseTransformer:
 
         # otherwise, we don't know the type
         raise RuntimeError(f"Unknown type to transform {type(value)}")
-
-
-hcl2_reconstructor = HCLReconstructor(reconstruction_parser())
-hcl2_reverse_transformer = HCLReverseTransformer()

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/hcl2/transformer.py

@@ -5,6 +5,7 @@ import sys
 from collections import namedtuple
 from typing import List, Dict, Any
 
+from lark import Token
 from lark.tree import Meta
 from lark.visitors import Transformer, Discard, _DiscardType, v_args
 
@@ -51,7 +52,6 @@ class DictTransformer(Transformer):
     def expr_term(self, args: List) -> Any:
         args = self.strip_new_line_tokens(args)
 
-        #
         if args[0] == "true":
             return True
         if args[0] == "false":
@@ -59,10 +59,9 @@ class DictTransformer(Transformer):
         if args[0] == "null":
             return None
 
-        # if the expression starts with a paren then unwrap it
-        if args[0] == "(":
-            return args[1]
-        # otherwise return the value itself
+        if args[0] == "(" and args[-1] == ")":
+            return "".join(str(arg) for arg in args)
+
         return args[0]
 
     def index_expr_term(self, args: List) -> str:
@@ -99,18 +98,27 @@ 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(args[0])
+        key = self.strip_quotes(str(args[0].children[0]))
         if len(args) == 3:
-            value = self.to_string_dollar(args[2])
+            value = args[2]
         else:
-            value = self.to_string_dollar(args[1])
+            value = args[1]
 
+        value = self.to_string_dollar(value)
         return {key: value}
 
+    def object_elem_key_dot_accessor(self, args: List) -> str:
+        return "".join(args)
+
     def object(self, args: List) -> Dict:
         args = self.strip_new_line_tokens(args)
         result: Dict[str, Any] = {}
         for arg in args:
+            if (
+                isinstance(arg, Token) and arg.type == "COMMA"
+            ):  # skip optional comma at the end of object element
+                continue
+
             result.update(arg)
         return result
 
@@ -134,10 +142,7 @@ class DictTransformer(Transformer):
         return f"{provider_func}({args_str})"
 
     def arguments(self, args: List) -> List:
-        return args
-
-    def new_line_and_or_comma(self, args: List) -> _DiscardType:
-        return Discard
+        return self.process_nulls(args)
 
     @v_args(meta=True)
     def block(self, meta: Meta, args: List) -> Dict:
@@ -167,16 +172,19 @@ class DictTransformer(Transformer):
 
     def conditional(self, args: List) -> str:
         args = self.strip_new_line_tokens(args)
+        args = self.process_nulls(args)
         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])
 
     def unary_op(self, args: List) -> str:
+        args = self.process_nulls(args)
         return "".join([self.to_tf_inline(arg) for arg in args])
 
     def binary_term(self, args: List) -> str:
         args = self.strip_new_line_tokens(args)
+        args = self.process_nulls(args)
         return " ".join([self.to_tf_inline(arg) for arg in args])
 
     def body(self, args: List) -> Dict[str, List]:
@@ -334,6 +342,9 @@ class DictTransformer(Transformer):
             # for now, but this method can be extended in the future
         return value
 
+    def process_nulls(self, args: List) -> List:
+        return ["null" if arg is None else arg for arg in args]
+
     def to_tf_inline(self, value: Any) -> str:
         """
         Converts complex objects (e.g.) dicts to an "inline" HCL syntax

python_hcl2-7.0.1/hcl2/version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '7.0.1'
+__version_tuple__ = version_tuple = (7, 0, 1)

{python-hcl2-6.1.1 → python_hcl2-7.0.1/python_hcl2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-hcl2
-Version: 6.1.1
+Version: 7.0.1
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -22,6 +22,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.7.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: lark<2,>=1
+Dynamic: license-file
 
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/2e2015f9297346cbaa788c46ab957827)](https://app.codacy.com/gh/amplify-education/python-hcl2/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 [![Build Status](https://travis-ci.org/amplify-education/python-hcl2.svg?branch=master)](https://travis-ci.org/amplify-education/python-hcl2)
@@ -92,7 +94,7 @@ To see all the available options, run `tox -l`.
 
 ## Releasing
 
-To create a new releaes go to Releases page, press 'Draft a new release', create a tag
+To create a new release go to Releases page, press 'Draft a new release', create a tag
 with a version you want to be released, fill the release notes and press 'Publish release'.
 Github actions will take care of publishing it to PyPi.
 
@@ -109,3 +111,23 @@ We welcome pull requests! For your pull request to be accepted smoothly, we sugg
 - Create a pull request.  Explain why you want to make the change and what it’s for.
 
 We’ll try to answer any PR’s promptly.
+
+## Limitations
+
+### Error parsing string interpolations nested more than 2 times
+
+- Parsing following example is expected to throw out an exception and fail:
+  ```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"
+  }
+  ```

{python-hcl2-6.1.1 → python_hcl2-7.0.1}/python_hcl2.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ test-requirements.txt
 tox.ini
 tree-to-hcl2-reconstruction.md
 .github/CODEOWNERS
+.github/ISSUE_TEMPLATE/hcl2-parsing-error.md
 .github/workflows/codeql-analysis.yml
 .github/workflows/pr_check.yml
 .github/workflows/publish.yml

python-hcl2-6.1.1/hcl2/version.py

@@ -1,4 +0,0 @@
-# file generated by setuptools_scm
-# don't change, don't track in version control
-__version__ = version = '6.1.1'
-__version_tuple__ = version_tuple = (6, 1, 1)