pbi-parsers 0.7.8__py3-none-any.whl

pbi_parsers/pq/lexer.py

@@ -0,0 +1,219 @@
+import string
+
+from pbi_parsers.base import BaseLexer
+from pbi_parsers.base.tokens import TextSlice
+
+from .tokens import Token, TokenType
+
+WHITESPACE = ["\n", "\r", "\t", " ", "\f", "\v"]
+KEYWORDS = ("null", "true", "false")
+RESERVED_WORDS = (
+    ("type", TokenType.TYPE),
+    ("let", TokenType.LET),
+    ("if", TokenType.IF),
+    ("then", TokenType.THEN),
+    ("else", TokenType.ELSE),
+    ("each", TokenType.EACH),
+    ("meta", TokenType.META),
+    ("nullable", TokenType.NULLABLE),
+    ("try", TokenType.TRY),
+    ("otherwise", TokenType.OTHERWISE),
+    ("and", TokenType.AND),
+    ("or", TokenType.OR),
+    ("not", TokenType.NOT),
+    ("in", TokenType.IN),
+    ("is", TokenType.IS),
+    ("as", TokenType.AS),
+)
+
+
+class Lexer(BaseLexer):
+    def scan(self) -> tuple[Token]:
+        return super().scan()  # type: ignore[override]
+
+    def create_token(self, tok_type: TokenType, start_pos: int) -> Token:
+        """Create a new token with the given type and text."""
+        text_slice = TextSlice(
+            full_text=self.source,
+            start=start_pos,
+            end=self.current_position,
+        )
+        return Token(tok_type=tok_type, text_slice=text_slice)
+
+    def _match_type_literal(self, start_pos: int) -> Token | None:
+        for c in ("int64.type", "currency.type"):
+            if self.match(c, case_insensitive=True):
+                return self.create_token(
+                    tok_type=TokenType.TYPE_LITERAL,
+                    start_pos=start_pos,
+                )
+        return None
+
+    def _match_reserved_words(self, start_pos: int) -> Token | None:
+        for name, token_type in RESERVED_WORDS:
+            if self.match(name, case_insensitive=True):
+                if not self.peek().isalpha():
+                    return self.create_token(tok_type=token_type, start_pos=start_pos)
+                # if the next character is an alpha character, it is not a keyword
+                # but an identifier, so we need to backtrack
+                self.advance(-len(name))
+        return None
+
+    def _match_keyword(self, start_pos: int) -> Token | None:
+        for keyword in KEYWORDS:
+            if self.match(keyword, case_insensitive=True):
+                return self.create_token(tok_type=TokenType.KEYWORD, start_pos=start_pos)
+        return None
+
+    def _match_hash_identifier(self, start_pos: int) -> Token | None:
+        if self.match('#"'):
+            while self.match(lambda c: c != '"') or self.match('""'):
+                pass
+            if self.match('"'):
+                return self.create_token(
+                    tok_type=TokenType.HASH_IDENTIFIER,
+                    start_pos=start_pos,
+                )
+            msg = f"Unterminated string literal at positions: {start_pos} to {self.current_position}"
+            raise ValueError(msg)
+
+        if self.match("#"):
+            while self.match(lambda c: c in string.ascii_letters + string.digits + "_"):
+                pass
+            return self.create_token(
+                tok_type=TokenType.HASH_IDENTIFIER,
+                start_pos=start_pos,
+            )
+
+        return None
+
+    def _match_string_literal(self, start_pos: int) -> Token | None:
+        if self.match('"'):
+            while self.match(lambda c: c != '"') or self.match('""'):
+                pass
+            if self.match('"'):
+                return self.create_token(
+                    tok_type=TokenType.STRING_LITERAL,
+                    start_pos=start_pos,
+                )
+            msg = f"Unterminated string literal at positions: {start_pos} to {self.current_position}"
+            raise ValueError(msg)
+
+        return None
+
+    def _match_whitespace(self, start_pos: int) -> Token | None:
+        if self.match(lambda c: c in WHITESPACE):
+            while self.match(lambda c: c in WHITESPACE):
+                pass
+            return self.create_token(
+                tok_type=TokenType.WHITESPACE,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_ellipsis(self, start_pos: int) -> Token | None:
+        if self.match("..."):
+            return self.create_token(
+                tok_type=TokenType.ELLIPSIS,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_period(self, start_pos: int) -> Token | None:
+        if self.match("."):
+            return self.create_token(
+                tok_type=TokenType.PERIOD,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_number_literal(self, start_pos: int) -> Token | None:
+        if self.match(
+            lambda c: c.isdigit() or c == ".",
+        ):  # must come before unquoted identifier to avoid conflict
+            while self.match(lambda c: c.isdigit() or c in {".", "e", "E"}):
+                pass
+            return self.create_token(
+                tok_type=TokenType.NUMBER_LITERAL,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_unquoted_identifier(self, start_pos: int) -> Token | None:
+        if self.match(lambda c: c.isalnum() or c == "_"):
+            while self.match(lambda c: c.isalnum() or c == "_"):
+                pass
+            return self.create_token(
+                tok_type=TokenType.UNQUOTED_IDENTIFIER,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_single_line_comment(self, start_pos: int) -> Token | None:
+        if self.match("//") or self.match("--"):
+            while self.match(lambda c: c not in {"\n", ""}):
+                pass
+            return self.create_token(
+                tok_type=TokenType.SINGLE_LINE_COMMENT,
+                start_pos=start_pos,
+            )
+        return None
+
+    def _match_token(self, start_pos: int) -> Token | None:
+        fixed_character_mapping = {
+            "=>": TokenType.LAMBDA_ARROW,
+            ">=": TokenType.COMPARISON_OPERATOR,
+            "=": TokenType.EQUAL_SIGN,
+            "(": TokenType.LEFT_PAREN,
+            ")": TokenType.RIGHT_PAREN,
+            "{": TokenType.LEFT_CURLY_BRACE,
+            "}": TokenType.RIGHT_CURLY_BRACE,
+            ",": TokenType.COMMA,
+            "[": TokenType.LEFT_BRACKET,
+            "]": TokenType.RIGHT_BRACKET,
+            "<>": TokenType.NOT_EQUAL_SIGN,
+            "+": TokenType.PLUS_SIGN,
+            "-": TokenType.MINUS_SIGN,
+            "*": TokenType.MULTIPLY_SIGN,
+            "/": TokenType.DIVIDE_SIGN,
+            ">": TokenType.COMPARISON_OPERATOR,
+            "&": TokenType.CONCATENATION_OPERATOR,
+            "!": TokenType.EXCLAMATION_POINT,
+        }
+
+        for char, token_type in fixed_character_mapping.items():
+            if self.match(char):
+                return self.create_token(
+                    tok_type=token_type,
+                    start_pos=start_pos,
+                )
+        return None
+
+    def scan_helper(self) -> Token:
+        start_pos: int = self.current_position
+
+        if not self.peek():
+            return Token()
+
+        for candidate_func in (
+            self._match_type_literal,
+            self._match_reserved_words,
+            # keywords have to be checked after the above tokens because "null" blocks "nullable"
+            self._match_keyword,
+            self._match_hash_identifier,
+            self._match_string_literal,
+            self._match_whitespace,
+            self._match_ellipsis,
+            self._match_period,
+            self._match_number_literal,
+            self._match_unquoted_identifier,
+            self._match_hash_identifier,
+            self._match_single_line_comment,
+            self._match_token,
+        ):
+            match_candidate = candidate_func(start_pos)
+            if match_candidate:
+                return match_candidate
+
+        msg = f"Unexpected character '{self.peek()}' at position {self.current_position}"
+        raise ValueError(msg)

pbi_parsers/pq/main.py

@@ -0,0 +1,63 @@
+from collections.abc import Iterable
+
+from .exprs._base import Expression
+from .formatter import Formatter
+from .lexer import Lexer
+from .parser import Parser
+from .tokens import Token, TokenType
+
+
+def remove_non_executing_tokens(tokens: Iterable[Token]) -> list[Token]:
+    """Removes tokens that are not executed in the M expression.
+
+    Args:
+        tokens (Iterable[Token]): Iterable of tokens to filter.
+
+    Returns:
+        list[Token]: Filtered list of tokens that are executed.
+
+    """
+    return list(
+        filter(
+            lambda x: x.tok_type
+            not in {
+                TokenType.WHITESPACE,
+                TokenType.SINGLE_LINE_COMMENT,
+                TokenType.MULTI_LINE_COMMENT,
+            },
+            tokens,
+        ),
+    )
+
+
+def to_ast(text: str) -> Expression | None:
+    """Converts an M expression string into an AST (Abstract Syntax Tree).
+
+    Args:
+        text (str): The M expression to parse.
+
+    Returns:
+        Expression | None: when matched, returns the root node of the AST representing the M expression.
+            When not matched, returns None.
+
+    """
+    tokens = Lexer(text).scan()
+    tokens = remove_non_executing_tokens(tokens)
+    parser = Parser(tokens)
+    return parser.to_ast()
+
+
+def format_expression(text: str) -> str:
+    """Formats an M expression string into a more readable format.
+
+    Args:
+        text (str): The M expression to format.
+
+    Returns:
+        str: The formatted M expression.
+
+    """
+    ast = to_ast(text)
+    if ast is None:
+        return text
+    return Formatter(ast).format()

pbi_parsers/pq/parser.py

@@ -0,0 +1,65 @@
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .exprs import Expression
+from .tokens import Token, TokenType
+
+EOF_TOKEN = Token()
+
+
+class Parser:
+    __tokens: list[Token]
+    index: int = 0
+    cache: dict[Any, Any]
+
+    def __init__(self, tokens: list[Token]) -> None:
+        self.__tokens = tokens
+        self.index = 0
+        self.cache = {}
+
+    def peek(self, forward: int = 0) -> Token:
+        """Peek at the next token without advancing the index.
+
+        Args:
+            forward (int): How many tokens to look ahead. Defaults to 0.
+
+        Returns:
+            Token: The token at the current index + forward.
+
+        """
+        if self.index + forward >= len(self.__tokens):
+            return EOF_TOKEN
+        return self.__tokens[self.index + forward]
+
+    def remaining(self) -> list[Token]:
+        """Returns the remaining tokens from the current index.
+
+        Returns:
+            list[Token]: The list of tokens from the current index to the end.
+
+        """
+        return self.__tokens[self.index :]
+
+    def to_ast(self) -> "Expression | None":
+        """Parse the tokens and return the root expression.
+
+        Raises:
+            ValueError: If no valid expression is found in the token stream.
+
+        """
+        from .exprs import any_expression_match  # noqa: PLC0415
+
+        ret = any_expression_match(self)
+        if ret is None:
+            msg = "No valid expression found in the token stream."
+            raise ValueError(msg)
+        assert self.peek().tok_type == TokenType.EOF
+        return ret
+
+    def consume(self) -> Token:
+        """Returns the next token and advances the index."""
+        if self.index >= len(self.__tokens):
+            return EOF_TOKEN
+        ret = self.__tokens[self.index]
+        self.index += 1
+        return ret

pbi_parsers/pq/tokens.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from pbi_parsers.base import BaseToken
+
+
+class TokenType(Enum):
+    LET = 1
+    EOF = 2
+    KEYWORD = 3
+    WHITESPACE = 4
+    UNQUOTED_IDENTIFIER = 5
+    QUOTED_IDENTIFER = 6
+    EQUAL_SIGN = 7
+    PERIOD = 8
+    LEFT_PAREN = 9
+    RIGHT_PAREN = 10
+    STRING_LITERAL = 11
+    LEFT_CURLY_BRACE = 12
+    RIGHT_CURLY_BRACE = 13
+    NUMBER_LITERAL = 14
+    COMMA = 15
+    LEFT_BRACKET = 16
+    RIGHT_BRACKET = 17
+    NOT_EQUAL_SIGN = 18
+    LAMBDA_ARROW = 19
+    PLUS_SIGN = 20
+    MINUS_SIGN = 21
+    MULTIPLY_SIGN = 22
+    DIVIDE_SIGN = 23
+    SINGLE_QUOTED_IDENTIFIER = 24
+    HASH_IDENTIFIER = 25
+    IN = 26
+    TYPE = 27
+    TYPE_LITERAL = 28
+    COMPARISON_OPERATOR = 29
+    IF = 31
+    ELSE = 32
+    THEN = 33
+    EACH = 34
+    META = 35
+    CONCATENATION_OPERATOR = 36
+    NULLABLE = 37
+    TRY = 38
+    OTHERWISE = 39
+    AND = 40
+    OR = 41
+    SINGLE_LINE_COMMENT = 42
+    MULTI_LINE_COMMENT = 43
+    ELLIPSIS = 44
+    NOT = 45
+    IS = 46
+    AS = 47
+    EXCLAMATION_POINT = 48
+
+
+@dataclass
+class Token(BaseToken):
+    tok_type: TokenType = TokenType.EOF
+
+
+# These are tokens that could also be used as identifiers in expressions.
+TEXT_TOKENS = (
+    TokenType.KEYWORD,
+    TokenType.LET,
+    TokenType.IN,
+    TokenType.TYPE,
+    TokenType.IF,
+    TokenType.ELSE,
+    TokenType.THEN,
+    TokenType.EACH,
+    TokenType.META,
+    TokenType.NULLABLE,
+    TokenType.TRY,
+    TokenType.OTHERWISE,
+    TokenType.AND,
+    TokenType.OR,
+    TokenType.NOT,
+    TokenType.IS,
+    TokenType.AS,
+)

pbi_parsers-0.7.8.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: pbi_parsers
+Version: 0.7.8
+Summary: Power BI lexer, parsers, and formatters for DAX and M (Power Query) languages
+Requires-Python: >=3.11.0
+Requires-Dist: jinja2>=3.1.6
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == 'dev'
+Requires-Dist: pre-commit>=3.8.0; extra == 'dev'
+Requires-Dist: ruff>=0.12.7; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.6.16; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.1; extra == 'docs'
+Requires-Dist: mkdocstrings-python>=0.30.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# Overview
+
+Based on [Crafting Interpreters](https://timothya.com/pdfs/crafting-interpreters.pdf). Library provides lexers, parsers, and formatters for DAX and Power Query (M) languages. Designed to support code introspection and analysis, not execution. This enables developement of [ruff](https://github.com/astral-sh/ruff)-equivalent tools for DAX and Power Query. It also enables extracting metadata from DAX and Power Query code, such PQ source types (Excel, SQL, etc.) and DAX lineage dependencies.
+
+For more information, see the [docs](https://douglassimonsen.github.io/pbi_parsers/)
+
+# Installation
+
+```shell
+python -m pip install pbi_parsers
+```
+
+# Dev Instructions
+
+
+## Set Up
+
+```shell
+python -m venv venv
+venv\Scripts\activate
+python -m pip install .
+pre-commit install
+```
+
+
+# Running the Documentation Server
+
+```shell
+python -m pip install .[docs]
+mkdocs serve -f docs/mkdocs.yml
+```
+
+## Deploy docs to Github Pages
+
+```shell
+mkdocs  gh-deploy --clean -f docs/mkdocs.yml
+```
+
+## Testing
+
+```shell
+
+pip install -e .
+```
+
+# Build Wheel
+
+```shell
+python -m build .
+```

pbi_parsers-0.7.8.dist-info/RECORD

@@ -0,0 +1,78 @@
+pbi_parsers/__init__.py,sha256=PjPoEsO9-jbGlmhpRxRgZdP4Xle5nERf4DeZu01DqvI,91
+pbi_parsers/base/__init__.py,sha256=U7QpzFFD9A4wK3ZHin6xg5fPgTca0y5KC-O7nrZ-flM,115
+pbi_parsers/base/lexer.py,sha256=9QonQzr-oLUdfW9XKWtQDLf2ZjalHXdTK-CyIX1AtN8,4174
+pbi_parsers/base/tokens.py,sha256=UPQqN21k9i55oEG-seW7msppnv35vHt23JOwYbVcVa4,2135
+pbi_parsers/dax/__init__.py,sha256=w8tfYFRwfjndq-QNnYQO3cu8fri4-OlG-edxUAKunF4,479
+pbi_parsers/dax/formatter.py,sha256=Ywbm3g_5GWcZJN6Eu8oGx_XdMuohqiCO77nMMB-P2us,7674
+pbi_parsers/dax/lexer.py,sha256=EsGjpVAS9HqRg0cP7j6Ro5WPd7zj7CldbLsuiw2fm0k,8025
+pbi_parsers/dax/main.py,sha256=mkkhW_lXv2sbRuQiOwNhF7RtQS5FdZLSdG8A5MOw-Wg,1657
+pbi_parsers/dax/parser.py,sha256=FtVL0KtP9ccisLElGIg0bR3dyVwFnLYWDXBGkjc6GUg,1821
+pbi_parsers/dax/tokens.py,sha256=nY1laCbL8vwALpJ4jcd8k4lAscqOwqdw3dFuj4_KKVk,1234
+pbi_parsers/dax/utils.py,sha256=ip5ALyKEPTNq38FrD0GzVhSTMbWTX9BdfQE1HI99mpY,4402
+pbi_parsers/dax/exprs/__init__.py,sha256=OUfiXzZYp5HkTPE9x595MMxpsgG1IvsED8p8spAKZuk,3432
+pbi_parsers/dax/exprs/_base.py,sha256=5CH82uz8q-gkeIsrcFHPR0-8mNMdHJed82Lc8DqwG9M,1634
+pbi_parsers/dax/exprs/_utils.py,sha256=zPDkfQjWlW2VMPYJSvXCpP7KfJlrn15Zz6fdMZNa3Os,1669
+pbi_parsers/dax/exprs/add_sub.py,sha256=Yy-Zuvf0Pg9PeN1J0-fufw7Q7bgaIcCM_MweR7dquxM,2241
+pbi_parsers/dax/exprs/add_sub_unary.py,sha256=21Sw3MJEcRIsv3OrT1C7Z9aqNa9-xnQR3ZZHSo2MJb8,2003
+pbi_parsers/dax/exprs/array.py,sha256=r7W21dS3_ZoegVA88DqbXvJJPrmjVw56Jyqg36h_7fE,2336
+pbi_parsers/dax/exprs/column.py,sha256=jH0QRNOfXTfwJpQhimCZzph-wCJQzzTp3se1w924hQg,1500
+pbi_parsers/dax/exprs/comparison.py,sha256=I2Ei00jBCb83qCvVgViIbX44QPUBJuafRp3MBAtZvms,2217
+pbi_parsers/dax/exprs/concatenation.py,sha256=ntzHPT171yJhzZOaHJAev1_Yq6XKFp-RkQAqcrlTrYo,2153
+pbi_parsers/dax/exprs/div_mul.py,sha256=PyDFs1BBUg6CS0TXG6-AIVN5qa_siaMeQsHOM9mUlg8,2316
+pbi_parsers/dax/exprs/exponent.py,sha256=vJ-PjkbzFFHhGXBU27DIhD4mY2wgsFxUJXYVjL0Oafc,1919
+pbi_parsers/dax/exprs/function.py,sha256=Vzo21E9jMuzpww6f1ulwNqxjfJp5eDpKYGsa17AEm_Q,3518
+pbi_parsers/dax/exprs/hierarchy.py,sha256=dNFBf1tKoal8GSi9SkT76RaMc4hPzmfSMGybgPo0CPE,1853
+pbi_parsers/dax/exprs/identifier.py,sha256=EZ3fAQMof2ccjF6qq2tE4J2SmlZZ624NbbYmdtBUDdQ,1151
+pbi_parsers/dax/exprs/ins.py,sha256=TENRz4YQHFe1UBLfFgzsaBryphe8lQR70FJmi6yw40w,1913
+pbi_parsers/dax/exprs/keyword.py,sha256=CrMAgGfcIREsQNWNgJKF5RhYNDLSrpVlZhG3vcjB96U,1803
+pbi_parsers/dax/exprs/literal_number.py,sha256=W0Uh2DU4BnDPtfo94xye3KAWETJIeiPOertQlcXxuek,1189
+pbi_parsers/dax/exprs/literal_string.py,sha256=8Qad6332-5Gb3qPxPIQYRfWU8WbFEmrsWH7bcfhpq_c,1188
+pbi_parsers/dax/exprs/logical.py,sha256=cDDZjkaKK9DMV0GxGSNuZ4VzyQz520ozl2mjYzJ-8cU,2197
+pbi_parsers/dax/exprs/measure.py,sha256=g0HLMxD29icBgCJ-R9enRrJgQrXrih0iz4CNcjZxMg8,1143
+pbi_parsers/dax/exprs/none.py,sha256=3a1S3CW9TEfutgUxtimGwCkDpZNWJniCDcYHErPHc-s,1018
+pbi_parsers/dax/exprs/parens.py,sha256=9c7KF4t_Cw0Co-Smw6EiF2CGBtbqILHxqQxQjn9dlTI,1927
+pbi_parsers/dax/exprs/returns.py,sha256=C-j3O4qM8q-ptftXCbyUYRlZ9btUn5RGin4f09zOg9s,2358
+pbi_parsers/dax/exprs/table.py,sha256=AWXtlvV1jkeeeGCnLn0qK7AFGILUCFkUMzYBJuQ3-yg,1185
+pbi_parsers/dax/exprs/variable.py,sha256=hRbd42D2Uu8AfE9wyUh0uvt0sV7PfAZChMBU2ixKFiM,1836
+pbi_parsers/pq/__init__.py,sha256=zYkl7_XQwBeNLAucRd0vgbIHO9kcnFaXy-zhgZdQ7xc,359
+pbi_parsers/pq/formatter.py,sha256=gcqj_aP8o5V10ULi5hdGhy3aAOy829jTKAfzH4mZewA,358
+pbi_parsers/pq/lexer.py,sha256=YOo4chz1N06FLO7cU4-wSoemIzfwG30NeUSJhJB-yOE,8093
+pbi_parsers/pq/main.py,sha256=4k5ZT-dRv5g2jjFgL1ckSpLR36wzClxe1YjiiIiBMu8,1649
+pbi_parsers/pq/parser.py,sha256=Fy8cqAGvGv1oVg4vYWJAGHZSWimEJ3wTtL5eqIkfOA8,1885
+pbi_parsers/pq/tokens.py,sha256=tll_fijLQ2reUJZIgyTW_a6ewuxiw9dva4dH9zx4GZ0,1637
+pbi_parsers/pq/exprs/__init__.py,sha256=wV-G51GagUAkA6_uVjsNA5JskO2JN3xXJPjKtzCH5rU,2845
+pbi_parsers/pq/exprs/_base.py,sha256=GcfWW3rannZBvw4LyjdiGbWGJ1nctw-m5k6LGkX7Wk4,1118
+pbi_parsers/pq/exprs/_utils.py,sha256=kUCWSzCSy7HMKOWcGjmO4R1WiYHP23afXmq67A0ZAXY,1065
+pbi_parsers/pq/exprs/add_sub.py,sha256=6h3OwaX87Xy82JV-inXpzFfdqoHhfZjiKpdaIJ39Tyk,1980
+pbi_parsers/pq/exprs/add_sub_unary.py,sha256=n_EMG1aNAuDjm95HJCgs28CUifeqzJzD8I388z7r1ok,1771
+pbi_parsers/pq/exprs/and_or_expr.py,sha256=wM8xufdnFgP8cuppubvF8ZpfyjPcPsrewNEt76gRWOs,1889
+pbi_parsers/pq/exprs/array.py,sha256=xdpeE9lUNDCWN7Nq9nT3QOOJ5RTrcruk4DKtwvwxXiI,1742
+pbi_parsers/pq/exprs/arrow.py,sha256=ANbvVIdEWlRlwv9lI5S7nuIKFv8lNfJ4qwjguCVtOuE,1546
+pbi_parsers/pq/exprs/column.py,sha256=fAKj0chGrlNaYJ6IVq6Vr9D3Ggq7OMrTiU4CE4xmuNc,1131
+pbi_parsers/pq/exprs/comparison.py,sha256=5OlvJEMu5QNjWNbnALMPVYzlcch7TNh8HxzDX3ZgLgg,2010
+pbi_parsers/pq/exprs/concatenation.py,sha256=DgQWQCIb6JiqvkHGYKs76dOFhvUES7tenI4XijaAdy4,1941
+pbi_parsers/pq/exprs/div_mul.py,sha256=wgkGtcTDolPzsyqCZzv4Dus8vUvEkJZswrCeTYmO_14,1980
+pbi_parsers/pq/exprs/each.py,sha256=8CM__HL1lzTR3cBlJyr9wnGYJLOFYqdoHNyToj4jIYc,1142
+pbi_parsers/pq/exprs/ellipsis_expr.py,sha256=_nPSaVwUKoVYUd_SzNI9rhSUUJf2x-0gBo3-6indNPM,807
+pbi_parsers/pq/exprs/function.py,sha256=UyqpgfJNDGggMFJCippt-6Nmzoy-cMBO9DpPudxwAYQ,2025
+pbi_parsers/pq/exprs/identifier.py,sha256=xTFpKrgiy6romsHbS9nNJ1kOgRbbfyUSzAY_jxXWVso,2492
+pbi_parsers/pq/exprs/if_expr.py,sha256=UZjOCndG0-vurYdNwZF7nA_hCTMiqQBNRNEE9V8Kp1Y,2084
+pbi_parsers/pq/exprs/is_expr.py,sha256=kn0YqSSXi8_4sFKECv5M3Kc_fCz0cbQ8xQAIs4i_Kdw,1679
+pbi_parsers/pq/exprs/keyword.py,sha256=4QxiiBe_f8VL1XW6bVL9GkTgZyH5_3MtGOLU_URmG-4,1263
+pbi_parsers/pq/exprs/literal_number.py,sha256=XMFAZ1Csx-Du9DNfC-P0OUKofMZqmMdQjo6SQtOGgoY,872
+pbi_parsers/pq/exprs/literal_string.py,sha256=49QAUxWkpmX4gVuSElKifVJC6T_ATqdDjYRu5PjmlbM,872
+pbi_parsers/pq/exprs/meta.py,sha256=mNHqZl1iX23u6ML53aihf0t1Lkb5ts0tT8vbqumplgg,1668
+pbi_parsers/pq/exprs/negation.py,sha256=PFUHKc6v09ToK2tqUcI6NavA0lC21fDijSZAVq3Z2Lc,1552
+pbi_parsers/pq/exprs/none.py,sha256=Mg8RO43vcrkhQ0aKF_DriB5eY5G0oHONb35tnNHGeGk,717
+pbi_parsers/pq/exprs/not_expr.py,sha256=O1bENFowAIH9_cWfbbWYKVbNbXlLN1ekKU5NT4dnt4k,970
+pbi_parsers/pq/exprs/parens.py,sha256=M6NSjBzTNGnQ6bMDtEJwAIMUFLd8w1evNLjx8rAM7QM,1265
+pbi_parsers/pq/exprs/record.py,sha256=gdtXC5wSdrah_ob7bna-hoAFDviLH-DS9h6N3xBORvk,1836
+pbi_parsers/pq/exprs/row.py,sha256=_NJfM2GhOd_8qN_HonD_KMEjfJEXcTKI8rP_Ab6TDVY,1531
+pbi_parsers/pq/exprs/row_index.py,sha256=qYlJWt8yUGio36yKOgVwQ8TGYNeA37yszX5Xwqhj4ME,1695
+pbi_parsers/pq/exprs/statement.py,sha256=JSg48pGAU3Ka2pt4lzVsYlVOqGeF_ARGm8Ajf0lB1VY,2208
+pbi_parsers/pq/exprs/try_expr.py,sha256=UcnqfA-t9S1LVrKqeNUT8n4JJcO-ZQZoJrxAdjJ-GMA,1692
+pbi_parsers/pq/exprs/type_expr.py,sha256=hH5ubrIJaxwQsopNJHUZ4ByS1rHEgv2Tf8ocYqSukXM,2570
+pbi_parsers/pq/exprs/variable.py,sha256=wp4t0QHIGA264sXnWp7XVe1H8MJzMIOaoLNBQe-dfNk,1602
+pbi_parsers-0.7.8.dist-info/METADATA,sha256=NFK2jTKIQVQc_7SATdO-DdxEcW2WSVqe-83nhvsACUQ,1658
+pbi_parsers-0.7.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pbi_parsers-0.7.8.dist-info/RECORD,,

pbi_parsers-0.7.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any