pbi-parsers 0.7.8__py3-none-any.whl

pbi_parsers/pq/exprs/not_expr.py

@@ -0,0 +1,39 @@
+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 NotExpression(Expression):
+    expr: Expression
+
+    def __init__(
+        self,
+        expr: Expression,
+    ) -> None:
+        self.expr = expr
+
+    def pprint(self) -> str:
+        return f"Not ({self.expr.pprint()})"
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "NotExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        if parser.consume().tok_type != TokenType.NOT:
+            return None
+
+        expr = any_expression_match(parser)
+        if expr is None:
+            return None
+        return NotExpression(expr=expr)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.expr]

pbi_parsers/pq/exprs/parens.py

@@ -0,0 +1,43 @@
+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 ParenthesesExpression(Expression):
+    inner_statement: Expression | None
+
+    def __init__(self, inner_statement: Expression | None) -> None:
+        self.inner_statement = inner_statement
+
+    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
+
+        parser.consume()
+        # when paired with an arrow expression, the value may not exist
+        value = any_expression_match(parser)
+
+        if parser.consume().tok_type != TokenType.RIGHT_PAREN:
+            return None
+
+        return ParenthesesExpression(inner_statement=value)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.inner_statement] if self.inner_statement else []

pbi_parsers/pq/exprs/record.py

@@ -0,0 +1,58 @@
+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
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class RecordExpression(Expression):
+    args: list[tuple[IdentifierExpression, Expression]]
+
+    def __init__(self, args: list[tuple[IdentifierExpression, Expression]]) -> None:
+        self.args = args
+
+    def pprint(self) -> str:
+        args = ",\n".join(f"{arg[0].pprint()}: {arg[1].pprint()}" for arg in self.args)
+        args = textwrap.indent(args, " " * 4)[4:]
+        return f"""
+Record (
+    {args}
+)        """.strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "RecordExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        args: list[tuple[IdentifierExpression, Expression]] = []
+        if parser.consume().tok_type != TokenType.LEFT_BRACKET:
+            return None
+
+        while parser.peek().tok_type != TokenType.RIGHT_BRACKET:
+            name = IdentifierExpression.match(parser)
+            if name is None:
+                return None
+            if parser.consume().tok_type != TokenType.EQUAL_SIGN:
+                return None
+
+            value = any_expression_match(parser)
+            if value is None:
+                return None
+
+            args.append((name, value))
+
+            if parser.peek().tok_type == TokenType.COMMA:
+                parser.consume()
+
+        parser.consume()  # consume the right bracket
+        return RecordExpression(args=args)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [val for arg in self.args for val in arg]

pbi_parsers/pq/exprs/row.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
+from .identifier import IdentifierExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class RowExpression(Expression):
+    table: IdentifierExpression
+    indexer: Expression
+
+    def __init__(
+        self,
+        table: IdentifierExpression,
+        indexer: Expression,
+    ) -> None:
+        self.table = table
+        self.indexer = indexer
+
+    def pprint(self) -> str:
+        indexer = textwrap.indent(self.indexer.pprint(), " " * 4)[4:]
+        return f"""
+Table (
+    name: {self.table.pprint()},
+    indexer: {indexer}
+)        """.strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "RowExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        table = IdentifierExpression.match(parser)
+        if table is None:
+            return None
+        if parser.consume().tok_type != TokenType.LEFT_CURLY_BRACE:
+            return None
+        indexer = any_expression_match(parser)
+        if indexer is None:
+            return None
+        if parser.consume().tok_type != TokenType.RIGHT_CURLY_BRACE:
+            return None
+
+        return RowExpression(table=table, indexer=indexer)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.table, self.indexer]

pbi_parsers/pq/exprs/row_index.py

@@ -0,0 +1,57 @@
+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 RowIndexExpression(Expression):
+    table: Expression
+    indexer: Expression
+
+    def __init__(self, table: Expression, indexer: Expression) -> None:
+        self.table = table
+        self.indexer = indexer
+
+    def pprint(self) -> str:
+        table = textwrap.indent(self.table.pprint(), " " * 4)[4:]
+        indexer = textwrap.indent(self.indexer.pprint(), " " * 4)[4:]
+        return f"""
+Indexer (
+    table: {table},
+    indexer: {indexer}
+)        """.strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "RowIndexExpression | None":
+        from . import EXPRESSION_HIERARCHY, any_expression_match  # noqa: PLC0415
+
+        skip_index = EXPRESSION_HIERARCHY.index(
+            RowIndexExpression,
+        )  # intentionally inclusive of self to allow +-++- chains
+
+        table = any_expression_match(parser, skip_first=skip_index + 1)
+        if table is None:
+            return None
+
+        if parser.consume().tok_type != TokenType.LEFT_BRACKET:
+            return None
+
+        indexer = any_expression_match(parser)
+        if indexer is None:
+            return None
+
+        if parser.consume().tok_type != TokenType.RIGHT_BRACKET:
+            return None
+
+        return RowIndexExpression(table=table, indexer=indexer)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.table, self.indexer]

pbi_parsers/pq/exprs/statement.py

@@ -0,0 +1,67 @@
+import textwrap
+from typing import TYPE_CHECKING
+
+from pbi_parsers.pq.tokens import TokenType
+
+from ._base import Expression
+from ._utils import lexer_reset
+from .variable import VariableExpression
+
+if TYPE_CHECKING:
+    from pbi_parsers.pq.parser import Parser
+
+
+class StatementExpression(Expression):
+    statements: list[VariableExpression]
+    let_expr: Expression
+
+    def __init__(self, let_expr: Expression, statements: list[VariableExpression]) -> None:
+        self.let_expr = let_expr
+        self.statements = statements
+
+    def pprint(self) -> str:
+        let_expr = textwrap.indent(self.let_expr.pprint(), " " * 14)[14:]
+        statements = textwrap.indent(
+            ",\n".join(statement.pprint() for statement in self.statements),
+            " " * 17,
+        )[17:]
+        return f"""
+Statement (
+    statements: {statements}
+    let_expr: {let_expr}
+)
+""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "StatementExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        if parser.consume().tok_type != TokenType.LET:
+            return None
+
+        statements = []
+        while parser.peek().tok_type != TokenType.IN:
+            statements.append(VariableExpression.match(parser))
+
+            if parser.peek().tok_type == TokenType.COMMA:
+                parser.consume()
+            elif parser.peek().tok_type != TokenType.IN:
+                msg = f"Expected a comma or 'in' token, got {parser.peek().tok_type}"
+                raise ValueError(msg)
+        if not statements:
+            return None
+
+        if parser.consume().tok_type != TokenType.IN:
+            msg = "Expected 'in' token after let statements"
+            raise ValueError(msg)
+
+        in_expr = any_expression_match(parser)
+        if in_expr is None:
+            msg = "Expected an expression after 'in' token"
+            raise ValueError(msg)
+        return StatementExpression(statements=statements, let_expr=in_expr)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.let_expr, *self.statements]

pbi_parsers/pq/exprs/try_expr.py

@@ -0,0 +1,55 @@
+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 TryExpression(Expression):
+    try_expr: Expression
+    otherwise_expr: Expression
+
+    def __init__(self, try_expr: Expression, otherwise_expr: Expression) -> None:
+        self.try_expr = try_expr
+        self.otherwise_expr = otherwise_expr
+
+    def pprint(self) -> str:
+        try_expr = textwrap.indent(self.try_expr.pprint(), " " * 10)[10:]
+        otherwise_expr = textwrap.indent(self.otherwise_expr.pprint(), " " * 10)[10:]
+        return f"""
+Try (
+    try: {try_expr},
+    otherwise: {otherwise_expr}
+)""".strip()
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "TryExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        try_ = parser.consume()
+        if try_.tok_type != TokenType.TRY:
+            return None
+        try_expr: Expression | None = any_expression_match(
+            parser,
+        )  # this expression can recurse
+        if not try_expr:
+            return None
+
+        otherwise = parser.consume()
+        if otherwise.tok_type != TokenType.OTHERWISE:
+            return None
+        otherwise_expr = any_expression_match(parser)
+        if not otherwise_expr:
+            return None
+
+        return TryExpression(try_expr=try_expr, otherwise_expr=otherwise_expr)
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.try_expr, self.otherwise_expr]

pbi_parsers/pq/exprs/type_expr.py

@@ -0,0 +1,78 @@
+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 TypingExpression(Expression):
+    type_name: list[Token]
+    nullable: Token | None = None
+    column_mapping: Expression | None = None
+
+    def __init__(
+        self,
+        type_name: list[Token],
+        nullable: Token | None = None,
+        column_mapping: Expression | None = None,
+    ) -> None:
+        self.tok_type_name = type_name
+        self.nullable = nullable
+        self.column_mapping = column_mapping
+
+    def pprint(self) -> str:
+        type_name = ".".join(t.text for t in self.tok_type_name)
+        if self.column_mapping is None:
+            base = f"Type ({type_name})"
+        else:
+            column_mapping = textwrap.indent(self.column_mapping.pprint(), " " * 10)[10:]
+            base = f"""
+Type (
+    type: {type_name},
+    column: {column_mapping}
+)
+"""
+        return base
+
+    @classmethod
+    @lexer_reset
+    def match(cls, parser: "Parser") -> "TypingExpression | None":
+        from . import any_expression_match  # noqa: PLC0415
+
+        type_keyword = parser.consume()
+        if type_keyword.tok_type == TokenType.TYPE_LITERAL:
+            return TypingExpression(type_name=[type_keyword])
+        if type_keyword.tok_type != TokenType.TYPE:
+            return None
+
+        nullable = None
+        if parser.peek().tok_type == TokenType.NULLABLE:
+            nullable = parser.consume()
+
+        name_parts = [parser.consume()]
+        # single part name (i.e. no period)
+        while parser.peek().tok_type == TokenType.PERIOD:
+            period, name = parser.consume(), parser.consume()
+            if name.tok_type not in {TokenType.UNQUOTED_IDENTIFIER, TokenType.TYPE}:
+                return None
+            if period.tok_type != TokenType.PERIOD:
+                return None
+            name_parts.append(name)
+        if len(name_parts) == 1 and name_parts[0].text == "table":
+            column_mapping = any_expression_match(parser)
+        else:
+            column_mapping = None
+        return TypingExpression(
+            type_name=name_parts,
+            nullable=nullable,
+            column_mapping=column_mapping,
+        )
+
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.column_mapping] if self.column_mapping else []

pbi_parsers/pq/exprs/variable.py

@@ -0,0 +1,52 @@
+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 VariableExpression(Expression):
+    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(), " " * 17).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
+
+        var_name = parser.consume()
+        equal_sign = parser.consume()
+        if (
+            var_name.tok_type
+            not in {TokenType.QUOTED_IDENTIFER, TokenType.UNQUOTED_IDENTIFIER, TokenType.HASH_IDENTIFIER}
+            or equal_sign.tok_type != TokenType.EQUAL_SIGN
+        ):
+            return None
+
+        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]

pbi_parsers/pq/formatter.py

@@ -0,0 +1,13 @@
+from .exprs import Expression
+
+
+class Formatter:
+    expression: Expression
+
+    def __init__(self, expression: Expression) -> None:
+        self.expression = expression
+
+    def format(self) -> str:
+        # Implement the formatting logic here
+        msg = "Formatter.format method is not implemented."
+        raise NotImplementedError(msg)