pbi-parsers 0.7.8__py3-none-any.whl

pbi_parsers/dax/exprs/column.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class ColumnExpression(Expression):
+    """Represents a column of a table in DAX.
+
+    Examples:
+        Table[Column]
+        'Table Name'[Column Name]
+
+    """
+
+    table: Token
+    column: Token
+
+    def __init__(self, table: Token, column: Token) -> None:
+        self.table = table
+        self.column = column
+
+    def pprint(self) -> str:
+        return f"""
+Column (
+    {self.table.text},
+    {self.column.text}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ColumnExpression | None":
+        table, column = parser.consume(), parser.consume()
+        if table.tok_type not in {
+            TokenType.SINGLE_QUOTED_IDENTIFIER,
+            TokenType.UNQUOTED_IDENTIFIER,
+        }:
+            return None
+        if column.tok_type != TokenType.BRACKETED_IDENTIFIER:
+            return None
+        return ColumnExpression(table=table, column=column)
+
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def position(self) -> tuple[int, int]:
+        return self.table.text_slice.start, self.column.text_slice.end
+
+    def full_text(self) -> str:
+        return self.table.text_slice.full_text

pbi_parsers/dax/exprs/comparison.py

@@ -0,0 +1,76 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class ComparisonExpression(Expression):
+    """Represents a boolean comparison expression.
+
+    Examples:
+        1 <> 2
+        func() = 3
+        4 > 5
+        6 <= 7
+
+    """
+
+    operator: Token
+    left: Expression
+    right: Expression
+
+    def __init__(self, operator: Token, left: Expression, right: Expression) -> None:
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ComparisonExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(ComparisonExpression)
+
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        operator = parser.consume()
+
+        if not left_term:
+            return None
+        if operator.tok_type not in {
+            TokenType.EQUAL_SIGN,
+            TokenType.NOT_EQUAL_SIGN,
+            TokenType.COMPARISON_OPERATOR,
+        }:
+            return None
+
+        right_term = any_expression_match(parser=parser, skip_first=skip_index)
+        if right_term is None:
+            msg = f"Expected a right term after operator {operator.text}, found: {parser.peek()}"
+            raise ValueError(msg)
+        return ComparisonExpression(operator=operator, left=left_term, right=right_term)
+
+    def pprint(self) -> str:
+        left_str = textwrap.indent(self.left.pprint(), " " * 10)[10:]
+        right_str = textwrap.indent(self.right.pprint(), " " * 10)[10:]
+        return f"""
+Bool (
+    operator: {self.operator.text},
+    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.operator.text_slice.full_text

pbi_parsers/dax/exprs/concatenation.py

@@ -0,0 +1,73 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class ConcatenationExpression(Expression):
+    """Represents a concatenation operator on two elements.
+
+    Examples:
+        "Hello" & " World"
+        Table[Column] & " Text"
+
+    """
+
+    operator: Token
+    left: Expression
+    right: Expression
+
+    def __init__(self, operator: Token, left: Expression, right: Expression) -> None:
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ConcatenationExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(ConcatenationExpression)
+
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        operator = parser.consume()
+
+        if not left_term:
+            return None
+        if operator.tok_type != TokenType.AMPERSAND_OPERATOR:
+            return None
+
+        right_term = any_expression_match(parser=parser, skip_first=skip_index)
+        if right_term is None:
+            msg = f"Expected a right term after operator {operator.text}, found: {parser.peek()}"
+            raise ValueError(msg)
+        return ConcatenationExpression(
+            operator=operator,
+            left=left_term,
+            right=right_term,
+        )
+
+    def pprint(self) -> str:
+        left_str = textwrap.indent(self.left.pprint(), " " * 10).lstrip()
+        right_str = textwrap.indent(self.right.pprint(), " " * 10).lstrip()
+        return f"""
+Concat (
+    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.operator.text_slice.full_text

pbi_parsers/dax/exprs/div_mul.py

@@ -0,0 +1,75 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class DivMulExpression(Expression):
+    """Represents an multiplication or division expression.
+
+    Examples:
+        2 * 3
+        4 / 5
+        6 * 7
+        8 / func(1, 2)
+
+    """
+
+    operator: Token
+    left: Expression
+    right: Expression
+
+    def __init__(self, operator: Token, left: Expression, right: Expression) -> None:
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "DivMulExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(DivMulExpression)
+
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        operator = parser.consume()
+
+        if not left_term:
+            return None
+        if operator.tok_type not in {TokenType.MULTIPLY_SIGN, TokenType.DIVIDE_SIGN}:
+            return None
+
+        right_term = any_expression_match(parser=parser, skip_first=skip_index)
+        if right_term is None:
+            msg = f"Expected a right term after operator {operator.text}, found: {parser.peek()}"
+            raise ValueError(msg)
+        return DivMulExpression(operator=operator, left=left_term, right=right_term)
+
+    def pprint(self) -> str:
+        op_str = {
+            TokenType.MULTIPLY_SIGN: "Mul",
+            TokenType.DIVIDE_SIGN: "Div",
+        }[self.operator.tok_type]
+        left_str = textwrap.indent(self.left.pprint(), " " * 10)[10:]
+        right_str = textwrap.indent(self.right.pprint(), " " * 10)[10:]
+        return f"""
+{op_str} (
+    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.operator.text_slice.full_text

pbi_parsers/dax/exprs/exponent.py

@@ -0,0 +1,67 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class ExponentExpression(Expression):
+    """Represents the exponentiation operation in DAX.
+
+    Examples:
+        2 ^ 3
+        func() ^ 4
+
+    """
+
+    base: Expression
+    power: Expression
+
+    def __init__(self, base: Expression, power: Expression) -> None:
+        self.base = base
+        self.power = power
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ExponentExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(ExponentExpression)
+
+        base = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        operator = parser.consume()
+
+        if not base:
+            return None
+        if operator.tok_type != TokenType.EXPONENTIATION_SIGN:
+            return None
+
+        power = any_expression_match(parser=parser, skip_first=skip_index)
+        if power is None:
+            msg = f"Expected a power term after operator {operator.text}, found: {parser.peek()}"
+            raise ValueError(msg)
+        return ExponentExpression(base=base, power=power)
+
+    def pprint(self) -> str:
+        base_str = textwrap.indent(self.base.pprint(), " " * 10).lstrip()
+        power_str = textwrap.indent(self.power.pprint(), " " * 10).lstrip()
+        return f"""
+Exponent (
+    base: {base_str},
+    power: {power_str}
+)""".strip()
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.base, self.power]
+
+    def position(self) -> tuple[int, int]:
+        return self.base.position()[0], self.power.position()[1]
+
+    def full_text(self) -> str:
+        return self.base.full_text()

pbi_parsers/dax/exprs/function.py

@@ -0,0 +1,102 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+from .none import NoneExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class FunctionExpression(Expression):
+    """Represents a function call in DAX.
+
+    Examples:
+        SUM(Table[Column])
+        CALCULATE(SUM(Table[Column]), FILTER(Table, Table[Column] > 0))
+
+    """
+
+    name_parts: list[Token]  # necessary for function names with periods
+    args: list[Expression]
+    parens: tuple[Token, Token]  # left and right parentheses
+
+    def __init__(self, name_parts: list[Token], args: list[Expression], parens: tuple[Token, Token]) -> None:
+        self.name_parts = name_parts
+        self.args = args
+        self.parens = parens
+
+    def pprint(self) -> str:
+        args = ",\n".join(arg.pprint() for arg in self.args)
+        args = textwrap.indent(args, " " * 10)[10:]
+        return f"""
+Function (
+    name: {"".join(x.text for x in self.name_parts)},
+    args: {args}
+)        """.strip()
+
+    @classmethod
+    def _match_function_name(cls, parser: "Parser") -> list[Token] | None:
+        name_parts = [parser.consume()]
+        if name_parts[0].tok_type != TokenType.UNQUOTED_IDENTIFIER:
+            return None
+
+        while parser.peek().tok_type != TokenType.LEFT_PAREN:
+            period, name = parser.consume(), parser.consume()
+            if name.tok_type != TokenType.UNQUOTED_IDENTIFIER:
+                return None
+            if period.tok_type != TokenType.PERIOD:
+                return None
+            name_parts.extend((period, name))
+
+        return name_parts
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "FunctionExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        args: list[Expression] = []
+        name_parts = cls._match_function_name(parser)
+        if name_parts is None:
+            return None
+
+        left_paren = parser.consume()
+        if left_paren.tok_type != TokenType.LEFT_PAREN:
+            return None
+
+        while not cls.match_tokens(parser, [TokenType.RIGHT_PAREN]):
+            arg = any_expression_match(parser)
+            if arg is not None:
+                args.append(arg)
+            elif parser.peek().tok_type == TokenType.COMMA:
+                args.append(NoneExpression())
+            else:
+                msg = f"Unexpected token sequence: {parser.peek()}, {parser.index}"
+                raise ValueError(msg)
+
+            if not cls.match_tokens(parser, [TokenType.RIGHT_PAREN]):
+                assert parser.consume().tok_type == TokenType.COMMA
+
+        right_paren = parser.consume()
+        if right_paren.tok_type != TokenType.RIGHT_PAREN:
+            msg = f"Expected a right parenthesis, found: {right_paren}"
+            raise ValueError(msg)
+
+        return FunctionExpression(name_parts=name_parts, args=args, parens=(left_paren, right_paren))
+
+    def function_name(self) -> str:
+        return "".join(x.text for x in self.name_parts)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return self.args
+
+    def position(self) -> tuple[int, int]:
+        return self.parens[0].text_slice.start, self.parens[1].text_slice.end
+
+    def full_text(self) -> str:
+        return self.parens[0].text_slice.full_text

pbi_parsers/dax/exprs/hierarchy.py

@@ -0,0 +1,68 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class HierarchyExpression(Expression):
+    """Represents a hierarchy in DAX.
+
+    Examples:
+        Table[Column].[Level]
+        'Table Name'[Column Name].[Level Name]
+
+    """
+
+    table: Token
+    column: Token
+    level: Token
+
+    def __init__(self, table: Token, column: Token, level: Token) -> None:
+        self.table = table
+        self.column = column
+        self.level = level
+
+    def pprint(self) -> str:
+        return f"""
+Hierarchy (
+    table: {self.table.text},
+    column: {self.column.text},
+    level: {self.level.text}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "HierarchyExpression | None":
+        table, column, period, level = (
+            parser.consume(),
+            parser.consume(),
+            parser.consume(),
+            parser.consume(),
+        )
+        if table.tok_type not in {
+            TokenType.SINGLE_QUOTED_IDENTIFIER,
+            TokenType.UNQUOTED_IDENTIFIER,
+        }:
+            return None
+        if column.tok_type != TokenType.BRACKETED_IDENTIFIER:
+            return None
+        if period.tok_type != TokenType.PERIOD:
+            return None
+        if level.tok_type != TokenType.BRACKETED_IDENTIFIER:
+            return None
+        return HierarchyExpression(table=table, column=column, level=level)
+
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def position(self) -> tuple[int, int]:
+        return self.table.text_slice.start, self.level.text_slice.end
+
+    def full_text(self) -> str:
+        return self.table.text_slice.full_text

pbi_parsers/dax/exprs/identifier.py

@@ -0,0 +1,46 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class IdentifierExpression(Expression):
+    """Represents a simple identifier of a variable.
+
+    Examples:
+        VariableName
+        AnotherVariableName
+
+    """
+
+    name: Token
+
+    def __init__(self, name: Token) -> None:
+        self.name = name
+
+    def pprint(self) -> str:
+        return f"""
+Identifier ({self.name.text})""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "IdentifierExpression | None":
+        name = parser.consume()
+        if name.tok_type != TokenType.UNQUOTED_IDENTIFIER:
+            return None
+        return IdentifierExpression(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

pbi_parsers/dax/exprs/ins.py

@@ -0,0 +1,67 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class InExpression(Expression):
+    """Represents an IN check.
+
+    Examples:
+        1 IN {1, 2, 3}
+        "text" IN {"text", "other text"}
+
+    """
+
+    value: Expression
+    array: Expression
+
+    def __init__(self, value: Expression, array: Expression) -> None:
+        self.value = value
+        self.array = array
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "InExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(InExpression)
+
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        operator = parser.consume()
+
+        if not left_term:
+            return None
+        if operator.tok_type != TokenType.IN:
+            return None
+
+        right_term = any_expression_match(parser=parser, skip_first=skip_index)
+        if right_term is None:
+            msg = f"Expected a right term after operator {operator.text}, found: {parser.peek()}"
+            raise ValueError(msg)
+        return InExpression(value=left_term, array=right_term)
+
+    def pprint(self) -> str:
+        value_str = textwrap.indent(self.value.pprint(), " " * 11)[11:]
+        array_str = textwrap.indent(self.array.pprint(), " " * 11)[11:]
+        return f"""
+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

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import KEYWORD_MAPPING, Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+from .function import FunctionExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class KeywordExpression(Expression):
+    """Represents a keyword in DAX.
+
+    Examples:
+        TRUE
+        FALSE
+
+    """
+
+    name: Token
+
+    def __init__(self, name: Token) -> None:
+        self.name = name
+
+    def pprint(self) -> str:
+        return f"""
+Keyword ({self.name.text})""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "KeywordExpression | FunctionExpression | None":
+        name = parser.consume()
+        if name.tok_type not in KEYWORD_MAPPING.values():
+            return None
+        if name.text.lower() in {"true", "false"}:
+            p1 = parser.peek()
+            p2 = parser.peek(1)
+            if (p1.tok_type, p2.tok_type) == (TokenType.LEFT_PAREN, TokenType.RIGHT_PAREN):
+                # This is a special case for boolean keywords with parentheses.
+                # IDK why microsoft made TRUE() a function too
+                left_paren = parser.consume()
+                right_paren = parser.consume()
+                return FunctionExpression(
+                    name_parts=[name],
+                    args=[],
+                    parens=(left_paren, right_paren),
+                )
+        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