pbi-parsers 0.7.12__py3-none-any.whl → 0.7.20__py3-none-any.whl

pbi_parsers/__init__.py

@@ -1,6 +1,6 @@
 from . import dax, pq
 
-__version__ = "0.7.12"
+__version__ = "0.7.20"
 
 
 __all__ = [

pbi_parsers/base/lexer.py

@@ -17,10 +17,33 @@ class BaseLexer:
         self.current_position = 0
         self.tokens = []
 
-    def scan_helper(self) -> BaseToken:
-        """Contains the orchestration logic for converting tokens into expressions."""
-        msg = "Subclasses should implement match_tokens method."
-        raise NotImplementedError(msg)
+    def advance(self, chunk: int = 1) -> None:
+        """Advances the current position by the specified chunk size.
+
+        Generally used alongside peek to consume characters.
+
+        Args:
+            chunk (int): The number of characters to advance the current position.
+
+        Raises:
+            ValueError: If the current position exceeds a predefined MAX_POSITION (1,000,000 characters).
+                This is to avoid errors with the lexer causing the process to hang
+
+        """
+        if self.current_position > MAX_POSITION:
+            msg = f"Current position exceeds {MAX_POSITION:,} characters."
+            raise ValueError(msg)
+        self.current_position += chunk
+
+    def at_end(self) -> bool:
+        """Checks if the current position is at (or beyond) the end of the source.
+
+        Returns:
+            bool: True if the current position is at or beyond the end of the source, False
+                otherwise.
+
+        """
+        return self.current_position >= len(self.source)
 
     def match(
         self,
@@ -32,7 +55,6 @@ class BaseLexer:
         """Match a string or a callable matcher against the current position in the source.
 
         Args:
-        ----
             matcher (Callable[[str], bool] | str): A string to match or a callable that
                 takes a string and returns a boolean.
             chunk (int): The number of characters to check from the current position.
@@ -61,7 +83,7 @@ class BaseLexer:
         return False
 
     def peek(self, chunk: int = 1) -> str:
-        """Returns the next chunk of text from the current position. Defaults to a single character.
+        """Returns the next section of text from the current position of length `chunk`. Defaults to a single character.
 
         Args:
             chunk (int): The number of characters to return from the current position.
@@ -87,24 +109,6 @@ class BaseLexer:
         """
         return self.source[self.current_position :]
 
-    def advance(self, chunk: int = 1) -> None:
-        """Advances the current position by the specified chunk size.
-
-        Generally used alongside peek to consume characters.
-
-        Args:
-            chunk (int): The number of characters to advance the current position.
-
-        Raises:
-            ValueError: If the current position exceeds a predefined MAX_POSITION (1,000,000 characters).
-                This is to avoid errors with the lexer causing the process to hang
-
-        """
-        if self.current_position > MAX_POSITION:
-            msg = f"Current position exceeds {MAX_POSITION:,} characters."
-            raise ValueError(msg)
-        self.current_position += chunk
-
     def scan(self) -> tuple[BaseToken, ...]:
         """Repeatedly calls scan_helper until the end of the source is reached.
 
@@ -116,12 +120,7 @@ class BaseLexer:
             self.tokens.append(self.scan_helper())
         return tuple(self.tokens)
 
-    def at_end(self) -> bool:
-        """Checks if the current position is at (or beyond) the end of the source.
-
-        Returns:
-            bool: True if the current position is at or beyond the end of the source, False
-                otherwise.
-
-        """
-        return self.current_position >= len(self.source)
+    def scan_helper(self) -> BaseToken:
+        """Contains the orchestration logic for converting tokens into expressions."""
+        msg = "Subclasses should implement match_tokens method."
+        raise NotImplementedError(msg)

pbi_parsers/base/tokens.py

@@ -32,15 +32,20 @@ class BaseToken:
     tok_type: Any
     text_slice: TextSlice = field(default_factory=TextSlice)
 
+    def __eq__(self, other: object) -> bool:
+        """Checks equality based on token type and text slice."""
+        if not isinstance(other, BaseToken):
+            return NotImplemented
+        return self.tok_type == other.tok_type and self.text_slice == other.text_slice
+
+    def __hash__(self) -> int:
+        """Returns a hash based on token type and text slice."""
+        return hash((self.tok_type, self.text_slice))
+
     def __repr__(self) -> str:
         pretty_text = self.text_slice.get_text().replace("\n", "\\n").replace("\r", "\\r")
         return f"Token(type={self.tok_type.name}, text='{pretty_text}')"
 
-    @property
-    def text(self) -> str:
-        """Returns the text underlying the token."""
-        return self.text_slice.get_text()
-
     def position(self) -> tuple[int, int]:
         """Returns the start and end positions of the token.
 
@@ -50,12 +55,12 @@ class BaseToken:
         """
         return self.text_slice.start, self.text_slice.end
 
-    def __eq__(self, other: object) -> bool:
-        """Checks equality based on token type and text slice."""
-        if not isinstance(other, BaseToken):
-            return NotImplemented
-        return self.tok_type == other.tok_type and self.text_slice == other.text_slice
+    @property
+    def text(self) -> str:
+        """Returns the text underlying the token.
 
-    def __hash__(self) -> int:
-        """Returns a hash based on token type and text slice."""
-        return hash((self.tok_type, self.text_slice))
+        Returns:
+            str: The text of the token as a string.
+
+        """
+        return self.text_slice.get_text()

pbi_parsers/dax/exprs/_base.py

@@ -10,8 +10,17 @@ class Expression:
     pre_comments: list[Any] = []
     post_comments: list[Any] = []
 
-    def pprint(self) -> str:
-        msg = "Subclasses should implement this method."
+    def __repr__(self) -> str:
+        return self.pprint()
+
+    def children(self) -> list["Expression"]:
+        """Returns a list of child expressions."""
+        msg = "This method should be implemented by subclasses."
+        raise NotImplementedError(msg)
+
+    def full_text(self) -> str:
+        """Returns the full text of the expression."""
+        msg = "This method should be implemented by subclasses."
         raise NotImplementedError(msg)
 
     @classmethod
@@ -27,20 +36,11 @@ class Expression:
     def match_tokens(parser: "Parser", match_tokens: list[TokenType]) -> bool:
         return all(parser.peek(i).tok_type == token_type for i, token_type in enumerate(match_tokens))
 
-    def __repr__(self) -> str:
-        return self.pprint()
-
-    def children(self) -> list["Expression"]:
-        """Returns a list of child expressions."""
-        msg = "This method should be implemented by subclasses."
-        raise NotImplementedError(msg)
-
     def position(self) -> tuple[int, int]:
         """Returns the start and end positions of the expression in the source code."""
         msg = "This method should be implemented by subclasses."
         raise NotImplementedError(msg)
 
-    def full_text(self) -> str:
-        """Returns the full text of the expression."""
-        msg = "This method should be implemented by subclasses."
+    def pprint(self) -> str:
+        msg = "Subclasses should implement this method."
         raise NotImplementedError(msg)

pbi_parsers/dax/exprs/_utils.py

@@ -10,6 +10,17 @@ R = TypeVar("R")  # Represents the return type of the decorated function
 
 
 def lexer_reset(func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to reset the lexer state before and after parsing an expression.
+
+    This decorator performs the following actions:
+    1. Collects pre-comments before parsing.
+    2. Caches the result of the parsing function to avoid redundant parsing.
+    3. Collects post-comments after parsing.
+
+    The caching is required since the operator precedence otherwise leads to all other expressions being
+    called multiple times.
+    """
+
     def lexer_reset_inner(*args: P.args, **kwargs: P.kwargs) -> R:
         parser = args[1]
         if not isinstance(parser, Parser):

pbi_parsers/dax/exprs/add_sub.py

@@ -28,6 +28,13 @@ class AddSubExpression(Expression):
         self.left = left
         self.right = right
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]
+
+    def full_text(self) -> str:
+        return self.operator.text_slice.full_text
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "AddSubExpression | None":
@@ -52,6 +59,9 @@ class AddSubExpression(Expression):
             raise ValueError(msg)
         return AddSubExpression(operator=operator, left=left_term, right=right_term)
 
+    def position(self) -> tuple[int, int]:
+        return self.left.position()[0], self.right.position()[1]
+
     def pprint(self) -> str:
         op_str = "Add" if self.operator.text == "+" else "Sub"
         left_str = textwrap.indent(self.left.pprint(), " " * 10).lstrip()
@@ -61,13 +71,3 @@ class AddSubExpression(Expression):
     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/add_sub_unary.py

@@ -26,6 +26,13 @@ class AddSubUnaryExpression(Expression):
         self.operator = operator
         self.number = number
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.number]
+
+    def full_text(self) -> str:
+        return self.operator.text_slice.full_text
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "AddSubUnaryExpression | None":
@@ -53,6 +60,9 @@ class AddSubUnaryExpression(Expression):
             raise ValueError(msg)
         return AddSubUnaryExpression(operator=operator, number=number)
 
+    def position(self) -> tuple[int, int]:
+        return self.operator.text_slice.start, self.number.position()[1]
+
     def pprint(self) -> str:
         number = textwrap.indent(self.number.pprint(), " " * 12).lstrip()
         return f"""
@@ -60,13 +70,3 @@ Number (
     sign: {self.operator.text},
     number: {number},
 )""".strip()
-
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return [self.number]
-
-    def position(self) -> tuple[int, int]:
-        return self.operator.text_slice.start, self.number.position()[1]
-
-    def full_text(self) -> str:
-        return self.operator.text_slice.full_text

pbi_parsers/dax/exprs/array.py

@@ -26,13 +26,12 @@ class ArrayExpression(Expression):
         self.elements: list[Expression] = elements
         self.braces = braces
 
-    def pprint(self) -> str:
-        elements = ",\n".join(element.pprint() for element in self.elements)
-        elements = textwrap.indent(elements, " " * 14)[14:]
-        return f"""
-Array (
-    elements: {elements}
-)        """.strip()
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return self.elements
+
+    def full_text(self) -> str:
+        return self.braces[0].text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -64,12 +63,13 @@ Array (
 
         return ArrayExpression(elements=elements, braces=(left_brace, right_brace))
 
-    def children(self) -> list[Expression]:
-        """Returns a list of child expressions."""
-        return self.elements
-
     def position(self) -> tuple[int, int]:
         return self.braces[0].text_slice.start, self.braces[1].text_slice.end
 
-    def full_text(self) -> str:
-        return self.braces[0].text_slice.full_text
+    def pprint(self) -> str:
+        elements = ",\n".join(element.pprint() for element in self.elements)
+        elements = textwrap.indent(elements, " " * 14)[14:]
+        return f"""
+Array (
+    elements: {elements}
+)        """.strip()

pbi_parsers/dax/exprs/column.py

@@ -25,12 +25,12 @@ class ColumnExpression(Expression):
         self.table = table
         self.column = column
 
-    def pprint(self) -> str:
-        return f"""
-Column (
-    {self.table.text},
-    {self.column.text}
-)""".strip()
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.table.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -45,12 +45,12 @@ Column (
             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
+    def pprint(self) -> str:
+        return f"""
+Column (
+    {self.table.text},
+    {self.column.text}
+)""".strip()

pbi_parsers/dax/exprs/comparison.py

@@ -30,6 +30,13 @@ class ComparisonExpression(Expression):
         self.left = left
         self.right = right
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]
+
+    def full_text(self) -> str:
+        return self.operator.text_slice.full_text
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "ComparisonExpression | None":
@@ -55,6 +62,9 @@ class ComparisonExpression(Expression):
             raise ValueError(msg)
         return ComparisonExpression(operator=operator, left=left_term, right=right_term)
 
+    def position(self) -> tuple[int, int]:
+        return self.left.position()[0], self.right.position()[1]
+
     def pprint(self) -> str:
         left_str = textwrap.indent(self.left.pprint(), " " * 10)[10:]
         right_str = textwrap.indent(self.right.pprint(), " " * 10)[10:]
@@ -64,13 +74,3 @@ Bool (
     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

@@ -28,6 +28,13 @@ class ConcatenationExpression(Expression):
         self.left = left
         self.right = right
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]
+
+    def full_text(self) -> str:
+        return self.operator.text_slice.full_text
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "ConcatenationExpression | None":
@@ -53,6 +60,9 @@ class ConcatenationExpression(Expression):
             right=right_term,
         )
 
+    def position(self) -> tuple[int, int]:
+        return self.left.position()[0], self.right.position()[1]
+
     def pprint(self) -> str:
         left_str = textwrap.indent(self.left.pprint(), " " * 10).lstrip()
         right_str = textwrap.indent(self.right.pprint(), " " * 10).lstrip()
@@ -61,13 +71,3 @@ 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

@@ -30,6 +30,13 @@ class DivMulExpression(Expression):
         self.left = left
         self.right = right
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.left, self.right]
+
+    def full_text(self) -> str:
+        return self.operator.text_slice.full_text
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "DivMulExpression | None":
@@ -51,6 +58,9 @@ class DivMulExpression(Expression):
             raise ValueError(msg)
         return DivMulExpression(operator=operator, left=left_term, right=right_term)
 
+    def position(self) -> tuple[int, int]:
+        return self.left.position()[0], self.right.position()[1]
+
     def pprint(self) -> str:
         op_str = {
             TokenType.MULTIPLY_SIGN: "Mul",
@@ -63,13 +73,3 @@ class DivMulExpression(Expression):
     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

@@ -26,6 +26,13 @@ class ExponentExpression(Expression):
         self.base = base
         self.power = power
 
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return [self.base, self.power]
+
+    def full_text(self) -> str:
+        return self.base.full_text()
+
     @classmethod
     @lexer_reset
     def match(cls, parser: "Parser") -> "ExponentExpression | None":
@@ -47,6 +54,9 @@ class ExponentExpression(Expression):
             raise ValueError(msg)
         return ExponentExpression(base=base, power=power)
 
+    def position(self) -> tuple[int, int]:
+        return self.base.position()[0], self.power.position()[1]
+
     def pprint(self) -> str:
         base_str = textwrap.indent(self.base.pprint(), " " * 10).lstrip()
         power_str = textwrap.indent(self.power.pprint(), " " * 10).lstrip()
@@ -55,13 +65,3 @@ 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

@@ -29,30 +29,15 @@ class FunctionExpression(Expression):
         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
+    def children(self) -> list[Expression]:
+        """Returns a list of child expressions."""
+        return self.args
 
-        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))
+    def full_text(self) -> str:
+        return self.parens[0].text_slice.full_text
 
-        return name_parts
+    def function_name(self) -> str:
+        return "".join(x.text for x in self.name_parts)
 
     @classmethod
     @lexer_reset
@@ -88,15 +73,30 @@ Function (
 
         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
+    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

pbi_parsers/dax/exprs/hierarchy.py

@@ -27,13 +27,12 @@ class HierarchyExpression(Expression):
         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()
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.table.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -57,12 +56,13 @@ Hierarchy (
             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
+    def pprint(self) -> str:
+        return f"""
+Hierarchy (
+    table: {self.table.text},
+    column: {self.column.text},
+    level: {self.level.text}
+)""".strip()

pbi_parsers/dax/exprs/identifier.py

@@ -23,9 +23,12 @@ class IdentifierExpression(Expression):
     def __init__(self, name: Token) -> None:
         self.name = name
 
-    def pprint(self) -> str:
-        return f"""
-Identifier ({self.name.text})""".strip()
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.name.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -35,12 +38,9 @@ Identifier ({self.name.text})""".strip()
             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
+    def pprint(self) -> str:
+        return f"""
+Identifier ({self.name.text})""".strip()