lexcql-parser 1.3.0__tar.gz → 1.3.2__tar.gz

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lexcql-parser
-Version: 1.3.0
+Version: 1.3.2
 Summary: LexCQL Query Grammar and Parser
 Keywords: LexCQL,FCS,CQL,Query Parser
 Author: Erik Körner
@@ -107,7 +107,7 @@ Parsed queries can also be checked against their specification conformance.
 
 ```python
 from lexcql import QueryParser
-from lexcql.validation import LexCQLValidatorV0_3
+from lexcql.validation import LexCQLValidatorV0_3, SpecificationValidationError
 
 parser = QueryParser(enableSourceLocations=True)
 
@@ -172,9 +172,9 @@ Run style checks:
 # setup environment
 uv sync --extra style
 
+uv run isort --check --diff .
 uv run black --check .
 uv run flake8 . --show-source --statistics
-uv run isort --check --diff .
 ```
 
 Run tests:

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/README.md

@@ -67,7 +67,7 @@ Parsed queries can also be checked against their specification conformance.
 
 ```python
 from lexcql import QueryParser
-from lexcql.validation import LexCQLValidatorV0_3
+from lexcql.validation import LexCQLValidatorV0_3, SpecificationValidationError
 
 parser = QueryParser(enableSourceLocations=True)
 
@@ -132,9 +132,9 @@ Run style checks:
 # setup environment
 uv sync --extra style
 
+uv run isort --check --diff .
 uv run black --check .
 uv run flake8 . --show-source --statistics
-uv run isort --check --diff .
 ```
 
 Run tests:

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lexcql-parser"
-version = "1.3.0"
+version = "1.3.2"
 description = "LexCQL Query Grammar and Parser"
 readme = "README.md"
 license = "MIT"

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/src/lexcql/__init__.py

@@ -56,7 +56,7 @@ def antlr_parse(input: str) -> LexParser.QueryContext:
 # ---------------------------------------------------------------------------
 
 
-def parse(input: str, enableSourceLocations: bool = True) -> QueryNode:
+def parse(input: str, *, enableSourceLocations: bool = True) -> QueryNode:
     """Simple wrapper to generate a `QueryParser` and to parse some
     input string into a `QueryNode`.
 
@@ -75,7 +75,7 @@ def parse(input: str, enableSourceLocations: bool = True) -> QueryNode:
 
 
 def can_parse(input: str):
-    """Simple wrapper to check if the input string can be sucsessfully parsed.
+    """Simple wrapper to check if the input string can be successfully parsed.
 
     Args:
         input: raw input query string
@@ -166,7 +166,7 @@ def validate(
             return False
 
         errors = []
-        if not str(ex) == "unable to parse query":
+        if not str(ex).startswith("unable to parse query: "):
             errors.append(ErrorDetail(str(ex)))
         errors.extend(parser.errors)
         return errors

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/src/lexcql/parser.py

@@ -1,6 +1,5 @@
 import logging
 from abc import ABCMeta
-from abc import abstractmethod
 from collections import deque
 from dataclasses import dataclass
 from enum import Enum
@@ -107,7 +106,7 @@ class QueryVisitor(Generic[_R], metaclass=ABCMeta):
     # ----------------------------------------------------
     # same as antlr4.tree.Tree.ParseTreeVisitor
 
-    def visitChildren(self, node: "QueryNode") -> _R:
+    def visitChildren(self, node: "QueryNode") -> Optional[_R]:
         result = self.defaultResult()
         for i in range(node.child_count):
             if not self.shouldVisitNextChild(node, result):
@@ -121,12 +120,12 @@ class QueryVisitor(Generic[_R], metaclass=ABCMeta):
         return result
 
     def defaultResult(self) -> Optional[_R]:
-        return None
+        return None  # type: ignore
 
-    def aggregateResult(self, aggregate: _R, nextResult: _R) -> _R:
+    def aggregateResult(self, aggregate: Optional[_R], nextResult: Optional[_R]) -> Optional[_R]:
         return nextResult
 
-    def shouldVisitNextChild(self, node: "QueryNode", currentResult: _R) -> bool:
+    def shouldVisitNextChild(self, node: "QueryNode", currentResult: Optional[_R]) -> bool:
         return True
 
 
@@ -236,7 +235,7 @@ class SourceLocation:
         return f"{self.start}:{self.stop}"
 
 
-class QueryNode(metaclass=ABCMeta):
+class QueryNode(Generic[_R], metaclass=ABCMeta):
     """Base class for LexCQL expression tree nodes."""
 
     def __init__(
@@ -362,9 +361,8 @@ class QueryNode(metaclass=ABCMeta):
             strrepr += f"@{self.location.start}:{self.location.stop}"
         return strrepr
 
-    @abstractmethod
-    def accept(self, visitor: QueryVisitor) -> None:
-        pass
+    def accept(self, visitor: QueryVisitor) -> _R:
+        return visitor.visit(self)
 
 
 # ---------------------------------------------------------------------------
@@ -402,9 +400,6 @@ class Modifier(QueryNode):
             parts.append(f"@{self.location.start}:{self.location.stop}")
         return "".join(parts)
 
-    def accept(self, visitor: QueryVisitor) -> None:
-        visitor.visit(self)
-
 
 class Relation(QueryNode):
     """A LexCQL expression tree relation node."""
@@ -445,9 +440,6 @@ class Relation(QueryNode):
             parts.append(f"@{self.location.start}:{self.location.stop}")
         return "".join(parts)
 
-    def accept(self, visitor: QueryVisitor) -> None:
-        visitor.visit(self)
-
 
 class SearchClause(QueryNode):
     """A LexCQL expression tree search_clause node."""
@@ -500,9 +492,6 @@ class SearchClause(QueryNode):
             parts.append(f"@{self.location.start}:{self.location.stop}")
         return "".join(parts)
 
-    def accept(self, visitor: QueryVisitor) -> None:
-        visitor.visit(self)
-
 
 class SearchClauseGroup(QueryNode):
     """A LexCQL expression tree search_clausse_group node."""
@@ -581,9 +570,6 @@ class SearchClauseGroup(QueryNode):
             parts.append(f"@{self.location.start}:{self.location.stop}")
         return "".join(parts)
 
-    def accept(self, visitor: QueryVisitor) -> None:
-        visitor.visit(self)
-
 
 class Subquery(QueryNode):
     """A LexCQL expression tree search_clausse_group node."""
@@ -633,9 +619,6 @@ class Subquery(QueryNode):
             parts.append(f"@{self.location.start}:{self.location.stop}")
         return "".join(parts)
 
-    def accept(self, visitor: QueryVisitor) -> None:
-        visitor.visit(self)
-
 
 # ---------------------------------------------------------------------------
 
@@ -681,10 +664,12 @@ class ErrorListener(antlr4.error.ErrorListener.ErrorListener):
                 LOGGER.debug("query: %s", self.query)
                 LOGGER.debug("       %s^- %s", " " * pos, msg)
 
-            if isinstance(recognizer, LexParser):
-                LOGGER.debug("symbol: %s", recognizer.symbolicNames[offendingSymbol.type])
-                LOGGER.debug("literal: %s", recognizer.literalNames[offendingSymbol.type])
-                LOGGER.debug("token idx: %s", offendingSymbol.tokenIndex)
+            if isinstance(offendingSymbol, Token):
+                lit_name, sym_name = self._get_token_name(recognizer, offendingSymbol)
+                LOGGER.debug(
+                    f"symbol: literal={lit_name!r} symbol={sym_name!r} @token-idx={offendingSymbol.tokenIndex}"
+                )
+                LOGGER.debug(f"{recognizer=}")
 
         if pos is None:
             pos = column
@@ -698,6 +683,27 @@ class ErrorListener(antlr4.error.ErrorListener.ErrorListener):
             )
         )
 
+    @staticmethod
+    def _get_token_name(recognizer: Recognizer, symbol: Optional[Token]):
+        if not symbol:
+            return (None, None)
+        if not isinstance(recognizer, (LexLexer, LexParser)):
+            return (None, None)
+        if not hasattr(recognizer, "literalNames"):
+            return (None, None)
+        if not hasattr(recognizer, "symbolicNames"):
+            return (None, None)
+
+        type = symbol.type
+        lit_name = sym_name = None
+
+        if type < len(recognizer.literalNames):
+            lit_name = recognizer.literalNames[type]
+        if type < len(recognizer.symbolicNames):
+            sym_name = recognizer.symbolicNames[type]
+
+        return (lit_name, sym_name)
+
     def has_errors(self) -> bool:
         return bool(self.errors)
 
@@ -1038,7 +1044,7 @@ class ExpressionTreeBuilder(LexParserVisitor):
 class QueryParser:
     """A LexCQL query parser that produces LexCQL expression trees."""
 
-    def __init__(self, enableSourceLocations: bool = False):
+    def __init__(self, *, enableSourceLocations: bool = False):
         """[Constructor]
 
         Args:
@@ -1093,7 +1099,8 @@ class QueryParser:
                     for msg in error_listener.errors:
                         LOGGER.debug("ERROR: %s", msg)
 
-                raise QueryParserException("unable to parse query")
+                first_message = error_listener.errors[0].message if error_listener.errors else "?"
+                raise QueryParserException(f"unable to parse query: {first_message}")
         except ExpressionTreeBuilderException as ex:
             raise QueryParserException(str(ex)) from ex
         except QueryParserException:

{lexcql_parser-1.3.0 → lexcql_parser-1.3.2}/src/lexcql/validation.py

@@ -97,7 +97,7 @@ class Validator(QueryVisitorAdapter[_R], metaclass=ABCMeta):
 
         Returns:
             bool: ``True`` if query in valid, ``False`` if any error was recorded
-                  in the ``.errors`` attribute
+                  in the ``.errors`` attribute (or in ``.warnings`` if ``.warnings_as_errors``)
         """
         # allows to override the query string here
         if query is not None:
@@ -105,10 +105,15 @@ class Validator(QueryVisitorAdapter[_R], metaclass=ABCMeta):
 
         # reset list of errors
         self.errors = []
+        self.warnings = []
 
         self.visit(node)
 
-        return len(self.errors) == 0
+        num_issues = len(self.errors)
+        if self.warnings_as_errors:
+            num_issues += len(self.warnings)
+
+        return num_issues == 0
 
     def is_valid(self, node: QueryNode, *, query: Optional[str] = None) -> bool:
         """Convenience method that simply calls ``.validate()`` and returns
@@ -205,31 +210,31 @@ class Validator(QueryVisitorAdapter[_R], metaclass=ABCMeta):
             return self.stack[-1]
         return None
 
-    def visit_Subquery(self, node: Subquery) -> _R:
+    def visit_Subquery(self, node: Subquery) -> Optional[_R]:
         self.stack.append(node)
         result = super().visit_Subquery(node)
         self.stack.pop()
         return result
 
-    def visit_SearchClauseGroup(self, node: SearchClauseGroup) -> _R:
+    def visit_SearchClauseGroup(self, node: SearchClauseGroup) -> Optional[_R]:
         self.stack.append(node)
         result = super().visit_SearchClauseGroup(node)
         self.stack.pop()
         return result
 
-    def visit_SearchClause(self, node: SearchClause) -> _R:
+    def visit_SearchClause(self, node: SearchClause) -> Optional[_R]:
         self.stack.append(node)
         result = super().visit_SearchClause(node)
         self.stack.pop()
         return result
 
-    def visit_Relation(self, node: Relation) -> _R:
+    def visit_Relation(self, node: Relation) -> Optional[_R]:
         self.stack.append(node)
         result = super().visit_Relation(node)
         self.stack.pop()
         return result
 
-    def visit_Modifier(self, node: Modifier) -> _R:
+    def visit_Modifier(self, node: Modifier) -> Optional[_R]:
         self.stack.append(node)
         result = super().visit_Modifier(node)
         self.stack.pop()