pbi-parsers 0.7.8__py3-none-any.whl

pbi_parsers/dax/exprs/literal_number.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 LiteralNumberExpression(Expression):
+    """Represents a literal number in DAX.
+
+    Examples:
+        42
+        3.14
+        -1000
+
+    """
+
+    value: Token
+
+    def __init__(self, value: Token) -> None:
+        self.value = value
+
+    def pprint(self) -> str:
+        return f"Number ({self.value.text})"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "LiteralNumberExpression | None":
+        if cls.match_tokens(parser, [TokenType.NUMBER_LITERAL]):
+            value = parser.consume()
+            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

pbi_parsers/dax/exprs/literal_string.py

@@ -0,0 +1,45 @@
+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 LiteralStringExpression(Expression):
+    """A literal string in DAX.
+
+    Examples:
+        "Hello, World!"
+        "Another String"
+
+    """
+
+    value: Token
+
+    def __init__(self, value: Token) -> None:
+        self.value = value
+
+    def pprint(self) -> str:
+        return f"String ({self.value.text})"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "LiteralStringExpression | None":
+        if cls.match_tokens(parser, [TokenType.STRING_LITERAL]):
+            value = parser.consume()
+            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

pbi_parsers/dax/exprs/logical.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 LogicalExpression(Expression):
+    """AND/OR boolean expression in DAX.
+
+    Examples:
+        1 || 2
+        func() && 3
+
+    """
+
+    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") -> "LogicalExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(LogicalExpression)
+
+        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.DOUBLE_PIPE_OPERATOR,
+            TokenType.DOUBLE_AMPERSAND_OPERATOR,
+        }:
+            return None
+
+        right_term: Expression | None = 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 LogicalExpression(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"""
+Logical (
+    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.left.full_text()

pbi_parsers/dax/exprs/measure.py

@@ -0,0 +1,44 @@
+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 MeasureExpression(Expression):
+    """Represents a measure in DAX.
+
+    Examples:
+        [Measure Name]
+
+    """
+
+    name: Token
+
+    def __init__(self, name: Token) -> None:
+        self.name = name
+
+    def pprint(self) -> str:
+        return f"Measure ({self.name.text})"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "MeasureExpression | None":
+        if cls.match_tokens(parser, [TokenType.BRACKETED_IDENTIFIER]):
+            name = parser.consume()
+            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

pbi_parsers/dax/exprs/none.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING
+
+from ._base import Expression
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+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"
+
+    @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 ""

pbi_parsers/dax/exprs/parens.py

@@ -0,0 +1,61 @@
+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 ParenthesesExpression(Expression):
+    """Represents a parenthesized expression in DAX.
+
+    Examples:
+        (1 + 2)
+        (func())
+
+    """
+
+    inner_statement: Expression
+    parens: tuple[Token, Token]
+
+    def __init__(self, inner_statement: Expression, parens: tuple[Token, Token]) -> None:
+        self.inner_statement = inner_statement
+        self.parens = parens
+
+    def pprint(self) -> str:
+        return f"""
+Parentheses (
+    {self.inner_statement}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ParenthesesExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        if not cls.match_tokens(parser, [TokenType.LEFT_PAREN]):
+            return None
+
+        left_paren = parser.consume()
+        value = any_expression_match(parser)
+        if value is None:
+            msg = "ParenthesesExpression.match called without valid inner expression"
+            raise ValueError(msg)
+        right_paren = parser.consume()
+        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

pbi_parsers/dax/exprs/returns.py

@@ -0,0 +1,76 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.dax.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+from .variable import VariableExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.dax.parser import Parser
+
+
+class ReturnExpression(Expression):
+    """Represents a RETURN statement in DAX.
+
+    Examples:
+        VAR x = 1
+        RETURN x + 2
+
+        VAR x = 1
+        RETURN x
+
+    """
+
+    ret: Expression
+    variable_statements: list[VariableExpression]
+
+    def __init__(self, ret: Expression, variable_statements: list[VariableExpression]) -> None:
+        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()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "ReturnExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        if not cls.match_tokens(parser, [TokenType.VARIABLE]):
+            return None
+
+        statements: list[VariableExpression] = []
+        while not cls.match_tokens(parser, [TokenType.RETURN]):
+            statement = VariableExpression.match(parser)
+            if statement is None:
+                msg = "ReturnExpression.match called without valid inner expression"
+                raise ValueError(msg)
+            statements.append(statement)
+
+        assert parser.consume().tok_type == TokenType.RETURN  # Consume the return token
+        ret = any_expression_match(parser)
+        if ret is None:
+            msg = "ReturnExpression.match called without valid return expression"
+            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()

pbi_parsers/dax/exprs/table.py

@@ -0,0 +1,51 @@
+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 TableExpression(Expression):
+    """Represents a table in DAX.
+
+    Examples:
+        TableName
+        'Table Name'
+
+    """
+
+    name: Token
+
+    def __init__(self, name: Token) -> None:
+        self.name = name
+
+    def pprint(self) -> str:
+        return f"""
+Table (
+    {self.name.text}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "TableExpression | None":
+        name = parser.consume()
+        if name.tok_type not in {
+            TokenType.SINGLE_QUOTED_IDENTIFIER,
+            TokenType.UNQUOTED_IDENTIFIER,
+        }:
+            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

pbi_parsers/dax/exprs/variable.py

@@ -0,0 +1,68 @@
+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 VariableExpression(Expression):
+    """Represents a variable assignment in DAX.
+
+    Examples:
+        VAR x = 1
+        VAR y = x + 2
+
+        VAR z = func()
+
+    """
+
+    var_name: Token
+    statement: Expression
+
+    def __init__(self, var_name: Token, statement: Expression) -> None:
+        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()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "VariableExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        if not cls.match_tokens(
+            parser,
+            [TokenType.VARIABLE, TokenType.UNQUOTED_IDENTIFIER, TokenType.EQUAL_SIGN],
+        ):
+            return None
+
+        parser.consume()
+        var_name = parser.consume()
+        parser.consume()
+        statement = any_expression_match(parser)
+        if statement is None:
+            msg = "VariableExpression.match called without valid inner expression"
+            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