pbi-parsers 0.7.12__py3-none-any.whl → 0.7.20__py3-none-any.whl

pbi_parsers/dax/exprs/ins.py

@@ -26,6 +26,13 @@ class InExpression(Expression):
         self.value = value
         self.array = array
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.value, self.array]
+
+    def full_text(self) -> str:
+        return self.value.full_text()
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "InExpression | None":
@@ -47,6 +54,9 @@ class InExpression(Expression):
             raise ValueError(msg)
         return InExpression(value=left_term, array=right_term)
 
+    def position(self) -> tuple[int, int]:
+        return self.value.position()[0], self.array.position()[1]
+
     def pprint(self) -> str:
         value_str = textwrap.indent(self.value.pprint(), " " * 11)[11:]
         array_str = textwrap.indent(self.array.pprint(), " " * 11)[11:]
@@ -55,13 +65,3 @@ In (
     value: {value_str},
     array: {array_str}
 )""".strip()
-
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.value, self.array]
-
-    def position(self) -> tuple[int, int]:
-        return self.value.position()[0], self.array.position()[1]
-
-    def full_text(self) -> str:
-        return self.value.full_text()

pbi_parsers/dax/exprs/keyword.py

@@ -24,9 +24,12 @@ class KeywordExpression(Expression):
     def __init__(self, name: Token) -> None:
         self.name = name
 
-    def pprint(self) -> str:
-        return f"""
-Keyword ({self.name.text})""".strip()
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.name.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -49,12 +52,9 @@ Keyword ({self.name.text})""".strip()
                 )
         return KeywordExpression(name=name)
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:
         return self.name.text_slice.start, self.name.text_slice.end
 
-    def full_text(self) -> str:
-        return self.name.text_slice.full_text
+    def pprint(self) -> str:
+        return f"""
+Keyword ({self.name.text})""".strip()

pbi_parsers/dax/exprs/literal_number.py

@@ -16,6 +16,7 @@ class LiteralNumberExpression(Expression):
         42
         3.14
         -1000
+        1.1e2
 
     """
 
@@ -24,8 +25,12 @@ class LiteralNumberExpression(Expression):
     def __init__(self, value: Token) -> None:
         self.value = value
 
-    def pprint(self) -> str:
-        return f"Number ({self.value.text})"
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.value.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -35,12 +40,8 @@ class LiteralNumberExpression(Expression):
             return LiteralNumberExpression(value=value)
         return None
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:
         return self.value.text_slice.start, self.value.text_slice.end
 
-    def full_text(self) -> str:
-        return self.value.text_slice.full_text
+    def pprint(self) -> str:
+        return f"Number ({self.value.text})"

pbi_parsers/dax/exprs/literal_string.py

@@ -23,8 +23,12 @@ class LiteralStringExpression(Expression):
     def __init__(self, value: Token) -> None:
         self.value = value
 
-    def pprint(self) -> str:
-        return f"String ({self.value.text})"
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.value.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -34,12 +38,8 @@ class LiteralStringExpression(Expression):
             return LiteralStringExpression(value=value)
         return None
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:
         return self.value.text_slice.start, self.value.text_slice.end
 
-    def full_text(self) -> str:
-        return self.value.text_slice.full_text
+    def pprint(self) -> str:
+        return f"String ({self.value.text})"

pbi_parsers/dax/exprs/logical.py

@@ -28,6 +28,13 @@ class LogicalExpression(Expression):
         self.left = left
         self.right = right
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]
+
+    def full_text(self) -> str:
+        return self.left.full_text()
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "LogicalExpression | None":
@@ -55,6 +62,9 @@ class LogicalExpression(Expression):
             raise ValueError(msg)
         return LogicalExpression(operator=operator, left=left_term, right=right_term)
 
+    def position(self) -> tuple[int, int]:
+        return self.left.position()[0], self.right.position()[1]
+
     def pprint(self) -> str:
         left_str = textwrap.indent(self.left.pprint(), " " * 10).lstrip()
         right_str = textwrap.indent(self.right.pprint(), " " * 10).lstrip()
@@ -64,13 +74,3 @@ Logical (
     left: {left_str},
     right: {right_str}
 )""".strip()
-
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.left, self.right]
-
-    def position(self) -> tuple[int, int]:
-        return self.left.position()[0], self.right.position()[1]
-
-    def full_text(self) -> str:
-        return self.left.full_text()

pbi_parsers/dax/exprs/measure.py

@@ -22,8 +22,12 @@ class MeasureExpression(Expression):
     def __init__(self, name: Token) -> None:
         self.name = name
 
-    def pprint(self) -> str:
-        return f"Measure ({self.name.text})"
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.name.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -33,12 +37,8 @@ class MeasureExpression(Expression):
             return MeasureExpression(name=name)
         return None
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:
         return self.name.text_slice.start, self.name.text_slice.end
 
-    def full_text(self) -> str:
-        return self.name.text_slice.full_text
+    def pprint(self) -> str:
+        return f"Measure ({self.name.text})"

pbi_parsers/dax/exprs/none.py

@@ -9,22 +9,22 @@ if TYPE_CHECKING:
 class NoneExpression(Expression):
     """Used to represent the absence of a value, so far only occurring when a argument is skipped in a function."""
 
-    def pprint(self) -> str:  # noqa: PLR6301  # kept this way to match the interface
-        return "None"
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:  # noqa: PLR6301
+        """Returns the full text of the expression."""
+        return ""
 
     @classmethod
     def match(cls, parser: "Parser") -> "NoneExpression | None":
         msg = "NoneExpression.match should not be called, this is a placeholder for the absence of an expression."
         raise NotImplementedError(msg)
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:  # noqa: PLR6301
         """Returns the position of the expression."""
         return -1, -1
 
-    def full_text(self) -> str:  # noqa: PLR6301
-        """Returns the full text of the expression."""
-        return ""
+    def pprint(self) -> str:  # noqa: PLR6301  # kept this way to match the interface
+        return "None"

pbi_parsers/dax/exprs/parens.py

@@ -25,11 +25,13 @@ class ParenthesesExpression(Expression):
         self.inner_statement = inner_statement
         self.parens = parens
 
-    def pprint(self) -> str:
-        return f"""
-Parentheses (
-    {self.inner_statement}
-)""".strip()
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.inner_statement]
+
+    def full_text(self) -> str:
+        """Returns the full text of the expression."""
+        return self.parens[0].text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -48,14 +50,12 @@ Parentheses (
         assert right_paren.tok_type == TokenType.RIGHT_PAREN  # Consume the right parenthesis
         return ParenthesesExpression(inner_statement=value, parens=(left_paren, right_paren))
 
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.inner_statement]
-
     def position(self) -> tuple[int, int]:
         """Returns the position of the expression."""
         return self.parens[0].text_slice.start, self.parens[1].text_slice.end
 
-    def full_text(self) -> str:
-        """Returns the full text of the expression."""
-        return self.parens[0].text_slice.full_text
+    def pprint(self) -> str:
+        return f"""
+Parentheses (
+    {self.inner_statement}
+)""".strip()

pbi_parsers/dax/exprs/returns.py

@@ -30,17 +30,12 @@ class ReturnExpression(Expression):
         self.ret = ret
         self.variable_statements = variable_statements
 
-    def pprint(self) -> str:
-        return_val = textwrap.indent(self.ret.pprint(), " " * 12).lstrip()
-        statements = textwrap.indent(
-            ",\n".join(stmt.pprint() for stmt in self.variable_statements),
-            " " * 16,
-        ).lstrip()
-        return f"""
-Return (
-    Return: {return_val},
-    Statements: {statements}
-)""".strip()
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.ret, *self.variable_statements]
+
+    def full_text(self) -> str:
+        return self.ret.full_text()
 
     @classmethod
     @lexer_reset
@@ -65,12 +60,17 @@ Return (
             raise ValueError(msg)
         return ReturnExpression(ret=ret, variable_statements=statements)
 
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.ret, *self.variable_statements]
-
     def position(self) -> tuple[int, int]:
         return self.variable_statements[0].position()[0], self.ret.position()[1]
 
-    def full_text(self) -> str:
-        return self.ret.full_text()
+    def pprint(self) -> str:
+        return_val = textwrap.indent(self.ret.pprint(), " " * 12).lstrip()
+        statements = textwrap.indent(
+            ",\n".join(stmt.pprint() for stmt in self.variable_statements),
+            " " * 16,
+        ).lstrip()
+        return f"""
+Return (
+    Return: {return_val},
+    Statements: {statements}
+)""".strip()

pbi_parsers/dax/exprs/table.py

@@ -23,11 +23,12 @@ class TableExpression(Expression):
     def __init__(self, name: Token) -> None:
         self.name = name
 
-    def pprint(self) -> str:
-        return f"""
-Table (
-    {self.name.text}
-)""".strip()
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.name.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -40,12 +41,11 @@ Table (
             return None
         return TableExpression(name=name)
 
-    def children(self) -> list[Expression]:  # noqa: PLR6301
-        """Returns a list of child expressions."""
-        return []
-
     def position(self) -> tuple[int, int]:
         return self.name.text_slice.start, self.name.text_slice.end
 
-    def full_text(self) -> str:
-        return self.name.text_slice.full_text
+    def pprint(self) -> str:
+        return f"""
+Table (
+    {self.name.text}
+)""".strip()

pbi_parsers/dax/exprs/variable.py

@@ -28,14 +28,12 @@ class VariableExpression(Expression):
         self.var_name = var_name
         self.statement = statement
 
-    def pprint(self) -> str:
-        statement = textwrap.indent(self.statement.pprint(), " " * 15).lstrip()
-        return f"""
-Variable (
-    name: {self.var_name.text},
-    statement: {statement}
-)
-""".strip()
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.statement]
+
+    def full_text(self) -> str:
+        return self.var_name.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -57,12 +55,14 @@ Variable (
             raise ValueError(msg)
         return VariableExpression(var_name=var_name, statement=statement)
 
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.statement]
-
     def position(self) -> tuple[int, int]:
         return self.var_name.text_slice.start, self.statement.position()[1]
 
-    def full_text(self) -> str:
-        return self.var_name.text_slice.full_text
+    def pprint(self) -> str:
+        statement = textwrap.indent(self.statement.pprint(), " " * 15).lstrip()
+        return f"""
+Variable (
+    name: {self.var_name.text},
+    statement: {statement}
+)
+""".strip()

pbi_parsers/dax/formatter.py

@@ -103,12 +103,6 @@ class Formatter:
 }}
 """
 
-    @classmethod
-    def _format_comparison(cls, expr: ComparisonExpression) -> str:
-        left = cls._format_helper(expr.left)
-        right = cls._format_helper(expr.right)
-        return f"""{left} {expr.operator.text} {right}"""
-
     @classmethod
     def _format_column(cls, expr: ColumnExpression) -> str:
         table = expr.table.text
@@ -117,6 +111,12 @@ class Formatter:
         column = expr.column.text
         return f"{table}{column}"
 
+    @classmethod
+    def _format_comparison(cls, expr: ComparisonExpression) -> str:
+        left = cls._format_helper(expr.left)
+        right = cls._format_helper(expr.right)
+        return f"""{left} {expr.operator.text} {right}"""
+
     @classmethod
     def _format_concatenation(cls, expr: ConcatenationExpression) -> str:
         left = cls._format_helper(expr.left)
@@ -170,11 +170,11 @@ class Formatter:
         return expr.name.text
 
     @classmethod
-    def _format_literal_string(cls, expr: LiteralStringExpression) -> str:
+    def _format_literal_number(cls, expr: LiteralNumberExpression) -> str:
         return expr.value.text
 
     @classmethod
-    def _format_literal_number(cls, expr: LiteralNumberExpression) -> str:
+    def _format_literal_string(cls, expr: LiteralStringExpression) -> str:
         return expr.value.text
 
     @classmethod