pbi-parsers 0.7.19__tar.gz → 0.7.21__tar.gz

pbi_parsers-0.7.21/.github/workflows/deploy-docs.yml

@@ -0,0 +1,35 @@
+# Setup: go to https://github.com/<org/username>/<repo>/settings/actions and set Workflow permissions to "Read and write permissions"
+name: Deploy MkDocs Site
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+      - '.github/workflows/deploy-docs.yml'
+
+jobs:
+  deploy-docs:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+            fetch-depth: 0  # Fetch all history
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install MkDocs and theme
+        run: |
+          python -m pip install .[docs]
+
+      - name: Deploy documentation to GitHub Pages
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdocs gh-deploy --clean -f docs/mkdocs.yml

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/.github/workflows/deploy.yml

@@ -1,3 +1,4 @@
+# Setup: go to https://github.com/<org/username>/<repo>/settings/actions and set Workflow permissions to "Read and write permissions"
 name: Tag and Release on Version Change
 
 on:
@@ -17,6 +18,8 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+            fetch-depth: 0  # Fetch all history for tags
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -120,3 +123,24 @@ jobs:
 
       - name: Publish Package to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x' # Specify your desired Python version
+      - name: Install dependencies
+        run: |
+          pip install .[dev]
+      - name: Run tests with coverage
+        run: |
+          coverage run --source=pbi_parsers -m pytest tests/
+          coverage xml
+      - name: Upload coverage to Coveralls
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          format: cobertura
+          file: coverage.xml

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/.gitignore

@@ -2,4 +2,5 @@ __pycache__
 venv
 dist
 docs/site
-.env
+.env
+.coverage

pbi_parsers-0.7.21/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 douglassimonsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/PKG-INFO

@@ -1,12 +1,19 @@
 Metadata-Version: 2.4
 Name: pbi_parsers
-Version: 0.7.19
+Version: 0.7.21
 Summary: Power BI lexer, parsers, and formatters for DAX and M (Power Query) languages
+Project-URL: Homepage, https://github.com/douglassimonsen/pbi_parsers
+Project-URL: Documentation, https://douglassimonsen.github.io/pbi_parsers/
+License-File: LICENSE
 Requires-Python: >=3.11.0
+Requires-Dist: colorama>=0.4.6
 Requires-Dist: jinja2>=3.1.6
 Provides-Extra: dev
 Requires-Dist: build>=1.2.2; extra == 'dev'
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: coveralls; extra == 'dev'
 Requires-Dist: pre-commit>=3.8.0; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: ruff>=0.12.7; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material>=9.6.16; extra == 'docs'
@@ -16,6 +23,13 @@ Description-Content-Type: text/markdown
 
 # Overview
 
+[![PyPI Downloads](https://static.pepy.tech/badge/pbi-parsers)](https://pepy.tech/projects/pbi-parsers)
+![Python](https://img.shields.io/badge/python-3.11-blue.svg)
+[![Coverage Status](https://coveralls.io/repos/github/douglassimonsen/pbi_parsers/badge.svg?branch=main)](https://coveralls.io/github/douglassimonsen/pbi_parsers?branch=main)
+![Repo Size](https://img.shields.io/github/repo-size/douglassimonsen/pbi_parsers)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers?ref=badge_shield&issueType=license)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers?ref=badge_shield&issueType=security)
+
 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/)

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/README.md

@@ -1,5 +1,12 @@
 # Overview
 
+[![PyPI Downloads](https://static.pepy.tech/badge/pbi-parsers)](https://pepy.tech/projects/pbi-parsers)
+![Python](https://img.shields.io/badge/python-3.11-blue.svg)
+[![Coverage Status](https://coveralls.io/repos/github/douglassimonsen/pbi_parsers/badge.svg?branch=main)](https://coveralls.io/github/douglassimonsen/pbi_parsers?branch=main)
+![Repo Size](https://img.shields.io/github/repo-size/douglassimonsen/pbi_parsers)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers.svg?type=shield&issueType=license)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers?ref=badge_shield&issueType=license)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdouglassimonsen%2Fpbi_parsers?ref=badge_shield&issueType=security)
+
 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/)

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/docs/docs/index.md

@@ -1,6 +1,8 @@
 # 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 development 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.
+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 development 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. 
+
+This library is used in [pbi_ruff](https://github.com/douglassimonsen/pbi_ruff) to provide DAX and Power Query (M) linting.
 
 # Installation
 
@@ -11,7 +13,7 @@ python -m pip install pbi_parsers
 ## Functionality
 
 !!! info "Rust Implementation"
-    Although the library is primarily implemented in Python, there are plans to implement a Rust version for performance and efficiency.
+    Although the library is primarily implemented in Python, there are plans to implement a Rust version for performance and additional type-safety.
 
 - DAX
     * [x] Lexer

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/pbi_parsers/__init__.py

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

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/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-0.7.19 → pbi_parsers-0.7.21}/pbi_parsers/dax/exprs/literal_number.py

@@ -16,6 +16,7 @@ class LiteralNumberExpression(Expression):
         42
         3.14
         -1000
+        1.1e2
 
     """
 
@@ -24,8 +25,12 @@ class LiteralNumberExpression(Expression):
     def __init__(self, value: Token) -> None:
         self.value = value
 
-    def pprint(self) -> str:
-        return f"Number ({self.value.text})"
+    def children(self) -> list[Expression]:  # noqa: PLR6301
+        """Returns a list of child expressions."""
+        return []
+
+    def full_text(self) -> str:
+        return self.value.text_slice.full_text
 
     @classmethod
     @lexer_reset
@@ -35,12 +40,8 @@ class LiteralNumberExpression(Expression):
             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
+    def pprint(self) -> str:
+        return f"Number ({self.value.text})"

{pbi_parsers-0.7.19 → pbi_parsers-0.7.21}/pbi_parsers/dax/exprs/literal_string.py

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