pbi-parsers 0.7.8__py3-none-any.whl

pbi_parsers/pq/exprs/concatenation.py

@@ -0,0 +1,61 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class ConcatenationExpression(Expression):
+    """Represents an addition or subtraction expression."""
+
+    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.CONCATENATION_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]

pbi_parsers/pq/exprs/div_mul.py

@@ -0,0 +1,59 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class DivMulExpression(Expression):
+    """Represents an multiplication or division expression."""
+
+    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 = "Mul" if self.operator.text == "*" else "Div"
+        left_str = textwrap.indent(self.left.pprint(), " " * 10)[10:]
+        right_str = textwrap.indent(self.right.pprint(), " " * 10)[10:]
+        return f"""
+{op_str} (
+    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]

pbi_parsers/pq/exprs/each.py

@@ -0,0 +1,41 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class EachExpression(Expression):
+    each_expr: Expression
+
+    def __init__(self, each_expr: Expression) -> None:
+        self.each_expr = each_expr
+
+    def pprint(self) -> str:
+        each_expr = textwrap.indent(self.each_expr.pprint(), " " * 10)[10:]
+        return f"""
+Each (
+    each: {each_expr},
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "EachExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        each = parser.consume()
+        if each.tok_type != TokenType.EACH:
+            return None
+        each_expr: Expression | None = any_expression_match(parser)
+        if not each_expr:
+            return None
+        return EachExpression(each_expr=each_expr)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.each_expr]

pbi_parsers/pq/exprs/ellipsis_expr.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class EllipsisExpression(Expression):
+    def __init__(self) -> None:
+        pass
+
+    def pprint(self) -> str:  # noqa: PLR6301  # This is ignored because we want to match the interface
+        return "Ellipsis ()"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "EllipsisExpression | None":
+        if parser.consume().tok_type != TokenType.ELLIPSIS:
+            return None
+        return EllipsisExpression()
+
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []

pbi_parsers/pq/exprs/function.py

@@ -0,0 +1,63 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+from .identifier import IdentifierExpression
+from .none import NoneExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class FunctionExpression(Expression):
+    name: IdentifierExpression
+    args: list[Expression]
+
+    def __init__(self, name: IdentifierExpression, args: list[Expression]) -> None:
+        self.name = name
+        self.args = args
+
+    def pprint(self) -> str:
+        args = ",\n".join(arg.pprint() for arg in self.args)
+        args = textwrap.indent(args, " " * 10)[10:]
+        return f"""
+Function (
+    name: {self.name.pprint()},
+    args: {args}
+)        """.strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "FunctionExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        args: list[Expression] = []
+
+        name = IdentifierExpression.match(parser)
+        if name is None:
+            return None
+
+        if parser.consume().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()
+        return FunctionExpression(name=name, args=args)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.name, *self.args]

pbi_parsers/pq/exprs/identifier.py

@@ -0,0 +1,77 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TEXT_TOKENS, Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+NAME_PARTS = (
+    TokenType.QUOTED_IDENTIFER,
+    TokenType.UNQUOTED_IDENTIFIER,
+    TokenType.HASH_IDENTIFIER,
+    *TEXT_TOKENS,
+)
+
+
+class IdentifierExpression(Expression):
+    name_parts: list[Token]
+
+    def __init__(self, name_parts: list[Token]) -> None:
+        self.name_parts = name_parts
+
+    def pprint(self) -> str:
+        name = ".".join(part.text for part in self.name_parts)
+        return f"Identifier ({name})"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "IdentifierExpression | None":
+        name_parts = [parser.consume()]
+        if (
+            name_parts[0].tok_type not in NAME_PARTS
+        ):  # TEXT_TOKENS are used to allow keywords to be used as identifiers.
+            # This requires identifiers to be matched after keywords.
+            return None
+
+        while parser.peek().tok_type == TokenType.PERIOD:
+            _period, name = parser.consume(), parser.consume()
+            if name.tok_type not in NAME_PARTS:
+                return None
+            name_parts.append(name)
+
+        return IdentifierExpression(name_parts=name_parts)
+
+
+class BracketedIdentifierExpression(Expression):
+    name: list[Token]
+
+    def __init__(self, name_parts: list[Token]) -> None:
+        self.name_parts = name_parts
+
+    def pprint(self) -> str:
+        return f"""
+Bracketed Identifier ({" ".join(part.text for part in self.name_parts)})""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "BracketedIdentifierExpression | None":
+        left_bracket = parser.consume()
+        if left_bracket.tok_type != TokenType.LEFT_BRACKET:
+            return None
+        name_parts = []
+        while parser.peek().tok_type in {
+            *NAME_PARTS,
+            TokenType.PERIOD,
+        }:  # there are cases where keywords can be used as identifiers
+            name = parser.consume()
+            name_parts.append(name)
+        right_bracket = parser.consume()
+        if right_bracket.tok_type != TokenType.RIGHT_BRACKET:
+            return None
+        return BracketedIdentifierExpression(name_parts=name_parts)
+
+    def children(self) -> list[Expression]:
+        return super().children()

pbi_parsers/pq/exprs/if_expr.py

@@ -0,0 +1,70 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class IfExpression(Expression):
+    if_expr: Expression
+    then_expr: Expression
+    else_expr: Expression
+
+    def __init__(
+        self,
+        if_expr: Expression,
+        then_expr: Expression,
+        else_expr: Expression,
+    ) -> None:
+        self.if_expr = if_expr
+        self.then_expr = then_expr
+        self.else_expr = else_expr
+
+    def pprint(self) -> str:
+        if_expr = textwrap.indent(self.if_expr.pprint(), " " * 10)[10:]
+        then_expr = textwrap.indent(self.then_expr.pprint(), " " * 10)[10:]
+        else_expr = textwrap.indent(self.else_expr.pprint(), " " * 10)[10:]
+        return f"""
+If (
+    if: {if_expr},
+    then: {then_expr},
+    else: {else_expr}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "IfExpression | None":  # noqa: PLR0911
+        from . import any_expression_match  # noqa: PLC0415
+
+        if_ = parser.consume()
+        if if_.tok_type != TokenType.IF:
+            return None
+        if_expr: Expression | None = any_expression_match(
+            parser,
+        )  # this expression can recurse
+        if not if_expr:
+            return None
+
+        then = parser.consume()
+        if then.tok_type != TokenType.THEN:
+            return None
+        then_expr = any_expression_match(parser)
+        if not then_expr:
+            return None
+
+        else_ = parser.consume()
+        if else_.tok_type != TokenType.ELSE:
+            return None
+        else_expr = any_expression_match(parser)
+        if not else_expr:
+            return None
+        return IfExpression(if_expr=if_expr, then_expr=then_expr, else_expr=else_expr)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.if_expr, self.then_expr, self.else_expr]

pbi_parsers/pq/exprs/is_expr.py

@@ -0,0 +1,54 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class IsExpression(Expression):
+    """Represents an multiplication or division expression."""
+
+    left: Expression
+    right: Expression
+
+    def __init__(self, left: Expression, right: Expression) -> None:
+        self.left = left
+        self.right = right
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "IsExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(IsExpression)
+
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+
+        if not left_term:
+            return None
+        if parser.consume().tok_type != TokenType.IS:
+            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 "is", found: {parser.peek()}'
+            raise ValueError(msg)
+        return IsExpression(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"""
+Is (
+    left: {left_str},
+    right: {right_str}
+)""".strip()
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]

pbi_parsers/pq/exprs/keyword.py

@@ -0,0 +1,40 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class KeywordExpression(Expression):
+    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 | None":
+        name = parser.consume()
+        if name.tok_type != TokenType.KEYWORD:
+            return None
+        if name.text.lower() in {"true", "false"}:
+            p1 = parser.peek()
+            p2 = parser.peek(1)
+            if p1.tok_type == TokenType.LEFT_PAREN and p2.tok_type == TokenType.RIGHT_PAREN:
+                # This is a special case for boolean keywords with parentheses.
+                # IDK why microsoft made TRUE() a function too
+                parser.consume()
+                parser.consume()
+        return KeywordExpression(name=name)
+
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []

pbi_parsers/pq/exprs/literal_number.py

@@ -0,0 +1,31 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class LiteralNumberExpression(Expression):
+    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 []

pbi_parsers/pq/exprs/literal_string.py

@@ -0,0 +1,31 @@
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import Token, TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class LiteralStringExpression(Expression):
+    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 []

pbi_parsers/pq/exprs/meta.py

@@ -0,0 +1,54 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class MetaExpression(Expression):
+    left_term: Expression
+    right_term: Expression
+
+    def __init__(self, left_term: Expression, right_term: Expression) -> None:
+        self.left_term = left_term
+        self.right_term = right_term
+
+    def pprint(self) -> str:
+        left_term = textwrap.indent(self.left_term.pprint(), " " * 10)[10:]
+        right_term = textwrap.indent(self.right_term.pprint(), " " * 10)[10:]
+        return f"""
+Meta (
+    left: {left_term},
+    right: {right_term},
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "MetaExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(MetaExpression)
+        left_term = any_expression_match(parser=parser, skip_first=skip_index + 1)
+        if left_term is None:
+            return None
+
+        meta = parser.consume()
+        if meta.tok_type != TokenType.META:
+            return None
+
+        right_term: Expression | None = any_expression_match(
+            parser,
+        )  # this expression can recurse
+        if not right_term:
+            return None
+
+        return MetaExpression(left_term=left_term, right_term=right_term)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left_term, self.right_term]

pbi_parsers/pq/exprs/negation.py

@@ -0,0 +1,52 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class NegationExpression(Expression):
+    """Represents a negation expression."""
+
+    number: Expression
+
+    def __init__(self, number: Expression) -> None:
+        self.number = number
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "NegationExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(
+            NegationExpression,
+        )  # intentionally inclusive of self to allow +-++- chains
+
+        if parser.consume().tok_type != TokenType.EXCLAMATION_POINT:
+            return None
+
+        # Handle chained !!! prefixes
+        number: Expression | None = any_expression_match(
+            parser=parser,
+            skip_first=skip_index,
+        )
+        if number is None:
+            msg = f'Expected a right term after negation "!", found: {parser.peek()}'
+            raise ValueError(msg)
+        return NegationExpression(number=number)
+
+    def pprint(self) -> str:
+        number = textwrap.indent(self.number.pprint(), " " * 12).lstrip()
+        return f"""
+Negation (
+    number: {number},
+)""".strip()
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.number]

pbi_parsers/pq/exprs/none.py

@@ -0,0 +1,22 @@
+from typing import TYPE_CHECKING
+
+from ._base import Expression
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.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
+        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 []