python-hcl2 4.3.4__tar.gz → 5.0.0__tar.gz

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/.gitignore

@@ -121,3 +121,6 @@ node_modules/
 # Don't commit the generated parser
 lark_parser.py
 .lark_cache.bin
+
+# ASDF tool-versions file
+.tool-versions

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hcl2
-Version: 4.3.4
+Version: 5.0.0
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/hcl2/__init__.py

@@ -5,4 +5,4 @@ try:
 except ImportError:
     __version__ = "unknown"
 
-from .api import load, loads
+from .api import load, loads, parse, parses, transform, writes, AST

python-hcl2-5.0.0/hcl2/api.py

@@ -0,0 +1,69 @@
+"""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 hcl2
+from hcl2.transformer import DictTransformer
+
+
+def load(file: TextIO, with_meta=False) -> dict:
+    """Load a HCL2 file.
+    :param file: File with hcl2 to be loaded as a dict.
+    :param with_meta: If set to true then adds `__start_line__` and `__end_line__`
+    parameters to the output dict. Default to false.
+    """
+    return loads(file.read(), with_meta=with_meta)
+
+
+def loads(text: str, with_meta=False) -> dict:
+    """Load HCL2 from a string.
+    :param text: Text with hcl2 to be loaded as a dict.
+    :param with_meta: If set to true then adds `__start_line__` and `__end_line__`
+    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"
+    # 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 = hcl2.parse(text + "\n")
+    return DictTransformer(with_meta=with_meta).transform(tree)
+
+
+def parse(file: TextIO) -> AST:
+    """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:
+    """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.reconstructor import (  # pylint: disable=import-outside-toplevel
+        hcl2 as uncached_hcl2,
+    )
+
+    return uncached_hcl2.parse(text)
+
+
+def transform(ast: AST, with_meta=False) -> dict:
+    """Convert an HCL2 AST to a dictionary.
+    :param ast: HCL2 syntax tree, output from `parse` or `parses`
+    """
+    return DictTransformer(with_meta=with_meta).transform(ast)
+
+
+def writes(ast: AST) -> 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)

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/hcl2/hcl2.lark

@@ -1,11 +1,17 @@
 start : body
 body : (new_line_or_comment? (attribute | block))* new_line_or_comment?
-attribute : identifier "=" expression
+attribute : identifier EQ expression
 block : identifier (identifier | STRING_LIT)* new_line_or_comment? "{" body "}"
 new_line_and_or_comma: new_line_or_comment | "," | "," new_line_or_comment
-new_line_or_comment: ( /\n/ | /#.*\n/ | /\/\/.*\n/ )+
+new_line_or_comment: ( NL_OR_COMMENT )+
+NL_OR_COMMENT: /\n[ \t]*/ | /#.*\n/ | /\/\/.*\n/ | /\/\*(.|\n)*?(\*\/)/
 
-identifier : /[a-zA-Z_][a-zA-Z0-9_-]*/
+identifier : NAME | IN | FOR | IF | FOR_EACH
+NAME : /[a-zA-Z_][a-zA-Z0-9_-]*/
+IF : "if"
+IN : "in"
+FOR : "for"
+FOR_EACH : "for_each"
 
 ?expression : expr_term | operation | conditional
 
@@ -14,8 +20,9 @@ conditional : expression "?" new_line_or_comment? expression new_line_or_comment
 ?operation : unary_op | binary_op
 !unary_op : ("-" | "!") expr_term
 binary_op : expression binary_term new_line_or_comment?
-!binary_operator : "==" | "!=" | "<" | ">" | "<=" | ">=" | "-" | "*" | "/" | "%" | "&&" | "||" | "+"
+!binary_operator : BINARY_OP
 binary_term : binary_operator new_line_or_comment? expression
+BINARY_OP : "==" | "!=" | "<" | ">" | "<=" | ">=" | "-" | "*" | "/" | "%" | "&&" | "||" | "+"
 
 expr_term : "(" new_line_or_comment? expression new_line_or_comment? ")"
             | float_lit
@@ -27,7 +34,7 @@ expr_term : "(" new_line_or_comment? expression new_line_or_comment? ")"
             | index_expr_term
             | get_attr_expr_term
             | identifier
-            | provider_function_call 
+            | provider_function_call
             | heredoc_template
             | heredoc_template_trim
             | attr_splat_expr_term
@@ -46,10 +53,12 @@ int_lit : DECIMAL+
             | DECIMAL+ ("." DECIMAL+)? EXP_MARK DECIMAL+
 DECIMAL : "0".."9"
 EXP_MARK : ("e" | "E") ("+" | "-")?
+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) ("=" | ":") expression
+object_elem : (identifier | expression) ( EQ | ":") expression
+
 
 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)/
@@ -74,4 +83,3 @@ full_splat : "[*]" (get_attr | index)*
 !for_cond : "if" new_line_or_comment? expression
 
 %ignore /[ \t]+/
-%ignore /\/\*(.|\n)*?(\*\/)/

python-hcl2-5.0.0/hcl2/reconstructor.py

@@ -0,0 +1,162 @@
+"""A reconstructor for HCL2 implemented using Lark's experimental reconstruction functionality"""
+
+from lark import Lark
+from lark.reconstruct import Reconstructor
+from lark.utils import is_id_continue
+
+# this is duplicated from `parser` because we need different options here for
+# the reconstructor. please make sure changes are kept in sync between the two
+# if necessary.
+hcl2 = Lark.open(
+    "hcl2.lark",
+    parser="lalr",
+    # Caching must be disabled to allow for reconstruction until lark-parser/lark#1472 is fixed:
+    #
+    #   https://github.com/lark-parser/lark/issues/1472
+    #
+    # cache=str(PARSER_FILE),  # Disable/Delete file to effect changes to the grammar
+    rel_to=__file__,
+    propagate_positions=True,
+    maybe_placeholders=False,  # Needed for reconstruction
+)
+
+CHAR_SPACE_AFTER = set(',~@<>="|?)]:')
+CHAR_SPACE_BEFORE = (CHAR_SPACE_AFTER - set(",=")) | set("'")
+KEYWORDS_SPACE_AFTER = [
+    "if",
+    "in",
+    "for",
+    "for_each",
+    "==",
+    "!=",
+    "<",
+    ">",
+    "<=",
+    ">=",
+    "-",
+    "*",
+    "/",
+    "%",
+    "&&",
+    "||",
+    "+",
+]
+KEYWORDS_SPACE_BEFORE = KEYWORDS_SPACE_AFTER
+DIGITS = set("0123456789")
+NEVER_SPACE_AFTER = set("[(")
+NEVER_SPACE_BEFORE = set("]),.")
+NEVER_COMMA_BEFORE = set("])}")
+# characters that are OK to come right after an identifier with no space between
+IDENT_NO_SPACE = set("()[]")
+
+
+def _add_extra_space(prev_item, item):
+    # pylint: disable=too-many-boolean-expressions, too-many-return-statements
+
+    ##### the scenarios where explicitly disallow spaces: #####
+
+    # if we already have a space, don't add another
+    if prev_item[-1].isspace() or item[0].isspace():
+        return False
+
+    # none of the following should be separated by spaces:
+    # - groups of digits
+    # - namespaced::function::calls
+    # - characters within an identifier like array[0]()
+    if (
+        (prev_item[-1] in DIGITS and item[0] in DIGITS)
+        or item == "::"
+        or prev_item == "::"
+        or (prev_item[-1] in IDENT_NO_SPACE and item[0] in IDENT_NO_SPACE)
+    ):
+        return False
+
+    # specific characters are also blocklisted from having spaces
+    if prev_item[-1] in NEVER_SPACE_AFTER or item[0] in NEVER_SPACE_BEFORE:
+        return False
+
+    ##### the scenarios where we add spaces: #####
+
+    # scenario 1, the prev token ended with an identifier character
+    # and the next character is not an "IDENT_NO_SPACE" character
+    if is_id_continue(prev_item[-1]) and not item[0] in IDENT_NO_SPACE:
+        return True
+
+    # scenario 2, the prev token or the next token should be followed by a space
+    if (
+        prev_item[-1] in CHAR_SPACE_AFTER
+        or prev_item in KEYWORDS_SPACE_AFTER
+        or item[0] in CHAR_SPACE_BEFORE
+        or item in KEYWORDS_SPACE_BEFORE
+    ):
+        return True
+
+    # scenario 3, the previous token was a block opening brace and
+    # the next token is not a closing brace (so the block is on one
+    # line and not empty)
+    if prev_item[-1] == "{" and item[0] != "}":
+        return True
+
+    ##### otherwise, we don't add a space #####
+    return False
+
+
+def _postprocess_reconstruct(items):
+    """
+    Postprocess the stream of tokens derived from the AST during reconstruction.
+
+    For HCL2, this is used exclusively for adding whitespace in the right locations.
+    """
+    prev_item = ""
+    for item in items:
+        # first, handle any deferred tokens
+        if isinstance(prev_item, tuple) and prev_item[0] == "_deferred":
+            prev_item = prev_item[1]
+
+            # if the deferred token was a comma, see if we're ending a block
+            if prev_item == ",":
+                if item[0] not in NEVER_COMMA_BEFORE:
+                    yield prev_item
+            else:
+                yield prev_item
+
+        # if we're between two tokens, determine if we need to add an extra space
+        # we need the previous item and the current item to exist to evaluate these rules
+        if prev_item and item and _add_extra_space(prev_item, item):
+            yield " "
+
+        # in some cases, we may want to defer printing the next token
+        defer_item = False
+
+        # prevent the inclusion of extra commas if they are not intended
+        if item[0] == ",":
+            item = ("_deferred", item)
+            defer_item = True
+
+        # print the actual token
+        if not defer_item:
+            yield item
+
+        # store the previous item for the next token
+        prev_item = item
+
+    # if the last token was deferred, print it before continuing
+    if isinstance(prev_item, tuple) and prev_item[0] == "_deferred":
+        yield prev_item[1]
+
+
+class HCLReconstructor:
+    """This class converts a Lark.Tree AST back into a string representing the underlying HCL code."""
+    def __init__(self, parser):
+        self._recons = Reconstructor(parser)
+
+    def reconstruct(self, tree):
+        """Convert a Lark.Tree AST back into a string representation of HCL."""
+        return self._recons.reconstruct(
+            tree,
+            _postprocess_reconstruct,
+            insert_spaces=False,
+        )
+
+
+hcl2_reconstructor = HCLReconstructor(hcl2)

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/hcl2/transformer.py

@@ -93,7 +93,10 @@ class DictTransformer(Transformer):
         # 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])
-        value = self.to_string_dollar(args[1])
+        if len(args) == 3:
+            value = self.to_string_dollar(args[2])
+        else:
+            value = self.to_string_dollar(args[1])
 
         return {key: value}
 
@@ -116,7 +119,7 @@ class DictTransformer(Transformer):
         args_str = ""
         if len(args) > 5:
             args_str = ", ".join([str(arg) for arg in args[5] if arg is not Discard])
-        provider_func = "::".join([args[0],args[2],args[4]])
+        provider_func = "::".join([args[0], args[2], args[4]])
         return f"{provider_func}({args_str})"
 
     def arguments(self, args: List) -> List:
@@ -148,7 +151,7 @@ class DictTransformer(Transformer):
         key = str(args[0])
         if key.startswith('"') and key.endswith('"'):
             key = key[1:-1]
-        value = self.to_string_dollar(args[1])
+        value = self.to_string_dollar(args[2])
         return Attribute(key, value)
 
     def conditional(self, args: List) -> str:

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/hcl2/version.py

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

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/python_hcl2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hcl2
-Version: 4.3.4
+Version: 5.0.0
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT

{python-hcl2-4.3.4 → python-hcl2-5.0.0}/python_hcl2.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ hcl2/api.py
 hcl2/hcl2.lark
 hcl2/parser.py
 hcl2/py.typed
+hcl2/reconstructor.py
 hcl2/transformer.py
 hcl2/version.py
 python_hcl2.egg-info/PKG-INFO

python-hcl2-4.3.4/hcl2/api.py

@@ -1,28 +0,0 @@
-"""The API that will be exposed to users of this package"""
-from typing import TextIO
-
-from hcl2.parser import hcl2
-from hcl2.transformer import DictTransformer
-
-
-def load(file: TextIO, with_meta=False) -> dict:
-    """Load a HCL2 file.
-    :param file: File with hcl2 to be loaded as a dict.
-    :param with_meta: If set to true then adds `__start_line__` and `__end_line__`
-    parameters to the output dict. Default to false.
-    """
-    return loads(file.read(), with_meta=with_meta)
-
-
-def loads(text: str, with_meta=False) -> dict:
-    """Load HCL2 from a string.
-    :param text: Text with hcl2 to be loaded as a dict.
-    :param with_meta: If set to true then adds `__start_line__` and `__end_line__`
-    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"
-    # 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 = hcl2.parse(text + "\n")
-    return DictTransformer(with_meta=with_meta).transform(tree)