ransacklib 0.1.10__tar.gz → 0.1.11__tar.gz

{ransacklib-0.1.10 → ransacklib-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 0.1.10
+Version: 0.1.11
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: lark<1.3.0,>=1.2.2
@@ -19,14 +19,10 @@ Requires-Dist: ipranges<0.2,>=0.1.12
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: flake8-pytest-style; extra == "dev"
-Requires-Dist: flake8-bugbear; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: black; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
-Requires-Dist: isort; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

{ransacklib-0.1.10 → ransacklib-0.1.11}/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
   "lark>=1.2.2,<1.3.0",
   "ipranges>=0.1.12,<0.2",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [
   {name = "Rajmund H. Hruška", email = "rajmund.hruska@cesnet.cz"}
 ]
@@ -27,14 +27,10 @@ classifiers = [
 dev = [
   "pytest",
   "pytest-cov",
-  "flake8",
-  "flake8-pytest-style",
-  "flake8-bugbear",
   "sphinx",
   "sphinx_rtd_theme",
-  "black",
   "mypy",
-  "isort",
+  "ruff",
 ]
 
 [project.urls]
@@ -54,5 +50,35 @@ ransack = ["py.typed"]
 [tool.mypy]
 mypy_path = "$MYPY_CONFIG_FILE_DIR/typings"
 
-[tool.isort]
-profile = "black"
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "UP",  # pyupgrade
+    "PL",  # pylint
+    "PERF",  # Perflint
+    "FURB",  # refurb
+    "RUF",  # ruff-specific rules
+    "FLY",  # flynt
+    "B",  # flake8-bugbear
+    "A",  # flake8-builtins,
+    "C4",  # flake8-comprehensions
+    "DTZ",  # flake8-datetimez
+    "LOG",  # flake8-logging
+    "G",  # flake8-logging-format
+    "PIE",  # flake8-pie
+    "PYI",  # flake8-pyi
+    "PT",  # flake8-pytest-style
+    "RET",  # flake8-return
+    "SIM",  # flake8-simplify
+    "TC",  # flake8-type-checking
+    "ARG",  # flake8-unused-arguments
+    "PTH",  # flake8-use-pathlib
+]
+
+ignore = [
+    "PLR0913",  # too-many-arguments
+    "UP038",  # deprecated, will be removed
+]

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransack/__init__.py

@@ -2,14 +2,14 @@ from .exceptions import EvaluationError, ParseError, RansackError, ShapeError
 from .parser import Parser
 from .transformer import Filter, get_values
 
-__version__ = "0.1.10"
+__version__ = "0.1.11"
 
 __all__ = (
-    "get_values",
-    "Parser",
+    "EvaluationError",
     "Filter",
-    "RansackError",
     "ParseError",
+    "Parser",
+    "RansackError",
     "ShapeError",
-    "EvaluationError",
+    "get_values",
 )

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransack/exceptions.py

@@ -1,6 +1,6 @@
 """Custom exceptions for Ransack query parsing, evaluation, and shape validation."""
 
-from typing import Any, Optional
+from typing import Any
 
 
 class RansackError(Exception):
@@ -14,11 +14,11 @@ class PositionInfoMixin:
         self,
         line: int,
         column: int,
-        context: Optional[str] = None,
-        start_pos: Optional[int] = None,
-        end_pos: Optional[int] = None,
-        end_line: Optional[int] = None,
-        end_column: Optional[int] = None,
+        context: str | None = None,
+        start_pos: int | None = None,
+        end_pos: int | None = None,
+        end_line: int | None = None,
+        end_column: int | None = None,
         *args,
         **kwargs,
     ):
@@ -36,7 +36,9 @@ class ParseError(PositionInfoMixin, RansackError):
     """Raised when the input query cannot be parsed."""
 
     def __str__(self):
-        return f"Syntax error at line {self.line}, column {self.column}.\n\n{self.context}"  # noqa
+        return (
+            f"Syntax error at line {self.line}, column {self.column}.\n\n{self.context}"
+        )
 
 
 class ShapeError(PositionInfoMixin, RansackError):

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransack/operator.py

@@ -1,16 +1,15 @@
-import re
-from collections.abc import MutableSequence
+from collections.abc import Callable, MutableSequence
 from datetime import datetime, timedelta, timezone
 from functools import partial
 from numbers import Number
 from operator import add, eq, ge, gt, le, lt, mod, mul, sub, truediv
-from typing import Any, Callable, Union
+from typing import Any
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 
 from .exceptions import OperatorNotFoundError
 
-IP = Union[IP4, IP4Net, IP4Range, IP6, IP6Net, IP6Range]
+IP = IP4 | IP4Net | IP4Range | IP6 | IP6Net | IP6Range
 Operand = type | str
 
 commutative_operators = {"+", "*"}
@@ -189,7 +188,7 @@ def _comp_ip_ip(op: str, ip1: IP, ip2: IP) -> bool:
         case "<=":
             return ip1.low() <= ip2.high()
         case "=":
-            return ip1.low() == ip2.low() and ip1.high() == ip2.high()
+            return ip1 in ip2 or ip2 in ip1
         case _:
             raise OperatorNotFoundError(op, ("ip", "ip"), (ip1, ip2))
 
@@ -349,10 +348,12 @@ def _get_comp_dict(op: str, comp: Callable) -> dict[tuple[Operand, Operand], Cal
         (datetime, tuple): partial(_comp_scalar_range, op),
         (tuple, Number): partial(_comp_range_scalar, op),
         (tuple, datetime): partial(_comp_range_scalar, op),
+        (str, MutableSequence): partial(_comp_scalar_list, op),
         ("ip", MutableSequence): partial(_comp_scalar_list, op),
         (Number, MutableSequence): partial(_comp_scalar_list, op),
         (datetime, MutableSequence): partial(_comp_scalar_list, op),
         (timedelta, MutableSequence): partial(_comp_scalar_list, op),
+        (MutableSequence, str): partial(_comp_list_scalar, op),
         (MutableSequence, "ip"): partial(_comp_list_scalar, op),
         (MutableSequence, Number): partial(_comp_list_scalar, op),
         (MutableSequence, datetime): partial(_comp_list_scalar, op),
@@ -421,7 +422,7 @@ _operator_map: dict[str, dict[tuple[Operand, Operand], Callable]] = {
     ">=": _get_comp_dict(">=", ge),
     "<=": _get_comp_dict("<=", le),
     "<": _get_comp_dict("<", lt),
-    "=": _get_comp_dict("=", eq),
+    "=": _get_comp_dict("=", eq) | {(str, str): eq},
     ".": {
         (str, str): _concat,
         (MutableSequence, MutableSequence): _concat,
@@ -430,7 +431,6 @@ _operator_map: dict[str, dict[tuple[Operand, Operand], Callable]] = {
         (str, str): lambda value, pattern: pattern in value,
         (MutableSequence, str): lambda t, x: any(x in elem for elem in t),
     },
-    "like": {(str, str): lambda data, pattern: re.match(pattern, data) is not None},
     "in": {
         ("ip", "ip"): lambda left, right: left in right,
         (str, MutableSequence): _in_scalar_list,

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransack/parser.py

@@ -11,6 +11,8 @@ Classes:
               input data into an abstract syntax tree (AST).
 """
 
+import os
+from pathlib import Path
 from typing import Any, no_type_check
 
 from lark import Lark, Token, Tree
@@ -37,24 +39,23 @@ class Parser:
         ?start: or_expr
 
         ?or_expr: and_expr
-                | or_expr ("or" | "||")  and_expr    -> or_op
+                | or_expr ("or"i | "||")  and_expr      -> or_op
 
         ?and_expr: not_expr
-                 | and_expr ("and" | "&&") not_expr    -> and_op
+                 | and_expr ("and"i | "&&") not_expr    -> and_op
 
         ?not_expr: comparison
-                 | ("not" | "!") comparison    -> not_op
+                 | ("not"i | "!") comparison            -> not_op
 
         ?comparison: sum
-                   | sum ">" sum                                    -> gt
-                   | sum ">=" sum                                   -> gte
-                   | sum "<" sum                                    -> lt
-                   | sum "<=" sum                                   -> lte
-                   | sum "=" sum                                    -> any_eq
-                   | sum "==" sum                                   -> eq
-                   | sum ("like" | "LIKE") sum                      -> like_op
-                   | sum ("in" | "IN") sum                          -> in_op
-                   | sum ("contains" | "CONTAINS") sum              -> contains_op
+                   | sum ">" sum            -> gt
+                   | sum ">=" sum           -> gte
+                   | sum "<" sum            -> lt
+                   | sum "<=" sum           -> lte
+                   | sum "=" sum            -> any_eq
+                   | sum "==" sum           -> eq
+                   | sum "in"i sum          -> in_op
+                   | sum "contains"i sum    -> contains_op
 
         ?sum: product
             | sum "+" product            -> add
@@ -93,11 +94,11 @@ class Parser:
                   | IPV6_RANGE                   -> ipv6_range
                   | IPV6_CIDR                    -> ipv6_cidr
 
-        datetime: DATE ("T" | "t")? TIME         -> datetime_full
-                | DATE                           -> datetime_only_date
+        datetime: DATE "T"i? TIME    -> datetime_full
+                | DATE               -> datetime_only_date
 
         function: FUNCTION [args] ")"
-        args: atom ("," atom)*
+        args: or_expr ("," or_expr)*
 
         list: "[" [atom ("," atom)*] "]"
 
@@ -112,7 +113,7 @@ class Parser:
         TIME.2: /[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:[Zz]|(?:[+-][0-9]{2}:[0-9]{2}))?/
         TIMEDELTA.2: /([0-9]+[D|d])?[0-9]{2}:[0-9]{2}:[0-9]{2}/
         STRING: /"([^"]+)"|\'([^\']+)\'/
-        VARIABLE: /\.?[_a-zA-Z][-_a-zA-Z0-9]*(?:\.?[a-zA-Z][-_a-zA-Z0-9]*)*/
+        VARIABLE: /\.?[_a-zA-Z][-_a-zA-Z0-9]*(?:\.?[_a-zA-Z][-_a-zA-Z0-9]*)*/
         FUNCTION.2: /[_a-zA-Z][_a-zA-Z0-9]*\(/
 
         %import common.WS
@@ -128,7 +129,19 @@ class Parser:
             be referenced in queries. Context variables override data variables unless
             the data variable is explicitly accessed with a leading dot.
         """
-        self.parser = Lark(self.grammar, parser="lalr", propagate_positions=True)
+        # Determine the cache file of the grammar. By default, it's in the home
+        # directory. But when the environment variable is set, use the value
+        # from that variable. This is useful for GitLab CI/CD.
+        cache_path = os.getenv("RANSACK_CACHE_PATH")
+        if not cache_path:
+            cache_path = str(Path("~/.cache/ransack_grammar_cache").expanduser())
+
+        self.parser = Lark(
+            self.grammar,
+            parser="lalr",
+            propagate_positions=True,
+            cache=cache_path,
+        )
         self.shaper = ExpressionTransformer(context)
 
     @no_type_check

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransack/transformer.py

@@ -21,14 +21,14 @@ Classes:
 import re
 from collections.abc import Mapping, MutableSequence
 from datetime import datetime, timedelta, timezone
-from typing import Any, Optional, Tuple
+from typing import Any, cast
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 from lark import Token, Transformer, Tree, v_args
 from lark.tree import Meta
 from lark.visitors import Interpreter
 
-from .exceptions import EvaluationError
+from .exceptions import EvaluationError, RansackError
 from .function import predefined_functions
 from .operator import binary_operation
 
@@ -106,8 +106,8 @@ def _create_meta(token: Token | TokenWrapper) -> Meta:
 
 
 def _get_data_value(
-    path: str, data: Optional[Mapping | MutableSequence]
-) -> Tuple[Any, bool]:
+    path: str, data: Mapping | MutableSequence | None
+) -> tuple[Any, bool]:
     """
     Retrieves a value from the data structure (dictionary-like or list-like)
     based on a dotted path.
@@ -149,7 +149,7 @@ def _get_data_value(
             return None, False
         return _get_data_value(remaining_path, data[key])
 
-    elif isinstance(data, MutableSequence):
+    if isinstance(data, MutableSequence):
         # Aggregate results from all list elements
         aggregated: Any = []
         for item in data:
@@ -166,7 +166,7 @@ def _get_data_value(
     return None, False
 
 
-def get_values(data: Optional[Mapping | MutableSequence], path: str) -> list:
+def get_values(data: Mapping | MutableSequence | None, path: str) -> list:
     """
     Public API method to retrieve values from a nested data structure
     using a dotted path. Returns a flat list of values or an empty list
@@ -435,48 +435,6 @@ class ExpressionTransformer(Transformer):
             return Tree("var_from_context", [self.context[var]], _create_meta(var))
         return Tree("var_from_data", [TokenWrapper(var, var)], _create_meta(var))
 
-    def range_op(self, start: TokenWrapper, end: TokenWrapper):
-        """
-        Transforms a range operation (start to end) into an appropriate range object.
-
-        Parameters:
-            start: The start token of the range.
-            end: The end token of the range.
-
-        Returns:
-            A tree node wrapping a range object. If the tokens represent
-            IP addresses, the range will be transformed into an IP4Range
-            or IP6Range object, depending on the IP version; otherwise,
-            it will return a generic range operation node.
-        """
-
-        def _create_ip_node(range_class) -> Tree[TokenWrapper]:
-            """
-            Helper function to create a tree node for IP ranges.
-
-            Parameters:
-                range_class: The class (IP4Range or IP6Range) to instantiate.
-
-            Returns:
-                A tree node wrapping the created IP range object.
-            """
-            return Tree(
-                "ip",
-                [
-                    TokenWrapper(
-                        _add_tokens(_start.token, _end.token),
-                        range_class(f"{_start.token}-{_end.token}"),
-                    )
-                ],
-            )
-
-        _start, _end = start.children[0], end.children[0]
-        if isinstance(_start.real_value, IP4) and isinstance(_end.real_value, IP4):
-            return _create_ip_node(IP4Range)
-        elif isinstance(_start.real_value, IP6) and isinstance(_end.real_value, IP6):
-            return _create_ip_node(IP6Range)
-        return Tree("range_op", [start, end])
-
 
 @v_args(inline=True)
 class Filter(Interpreter):
@@ -489,7 +447,7 @@ class Filter(Interpreter):
 
     data = None
 
-    def eval(self, tree: Tree, data: Optional[dict] = None):
+    def eval(self, tree: Tree, data: dict | None = None):
         """
         Evaluates the given tree using the provided data.
 
@@ -501,6 +459,7 @@ class Filter(Interpreter):
             The result of evaluating the tree.
         """
         self.data = data if data is not None else {}
+        self.function_calls: dict[tuple[str, Tree | None], Any] = {}
 
         res = self.visit(tree)
 
@@ -570,6 +529,8 @@ class Filter(Interpreter):
     def _binary_operation(self, op: str, l_tree: Tree, r_tree: Tree) -> Any:
         try:
             return binary_operation(op, self.visit(l_tree), self.visit(r_tree))
+        except RansackError:
+            raise
         except Exception as e:
             raise EvaluationError(
                 str(e),
@@ -659,19 +620,6 @@ class Filter(Interpreter):
         """
         return not self.visit(tree)
 
-    def like_op(self, l_tree: Tree, r_tree: Tree) -> bool:
-        """
-        Checks if a string matches a regular expression pattern.
-
-        Parameters:
-            l_tree: Subtree representing the string to check.
-            r_tree: Subtree representing the regex pattern.
-
-        Returns:
-            True if the string matches the pattern, otherwise False.
-        """
-        return self._binary_operation("like", l_tree, r_tree)
-
     def in_op(self, l_tree: Tree, r_tree: Tree) -> bool:
         """
         Checks if a value exists within a data structure.
@@ -762,18 +710,25 @@ class Filter(Interpreter):
         """
         return [self.visit(x) for x in data.children if x is not None]
 
-    def range_op(self, l_tree: Tree, r_tree: Tree) -> tuple:
+    def range_op(self, l_tree: Tree, r_tree: Tree) -> tuple | IP4Range | IP6Range:
         """
-        Creates a tuple representing a range.
+        Creates a tuple representing a range, or IP4Range/IP6Range.
 
         Parameters:
             l_tree: Subtree representing the start of the range.
             r_tree: Subtree representing the end of the range.
 
         Returns:
-            A tuple containing the start and end values.
+            A tuple containing the start and end values or IP4Range/IP6Range
+            object for ip ranges.
         """
-        return (self.visit(l_tree), self.visit(r_tree))
+        start = self.visit(l_tree)
+        end = self.visit(r_tree)
+        if isinstance(start, IP4) and isinstance(end, IP4):
+            return IP4Range(f"{start}-{end}")
+        if isinstance(start, IP6) and isinstance(end, IP6):
+            return IP6Range(f"{start}-{end}")
+        return (start, end)
 
     def exists_op(self, path: Token) -> bool:
         """
@@ -809,6 +764,9 @@ class Filter(Interpreter):
         """
         Calls a predefined function with the given arguments.
 
+        Caches the returned value for a given tuple - function name and
+        its arguments - so it can return the same value for subsequent calls.
+
         Parameters:
             name: The name of the function as a TokenWrapper.
             args: A Tree object containing function arguments or None.
@@ -819,12 +777,17 @@ class Filter(Interpreter):
         Raises:
             ValueError: If the function name is not found in predefined functions.
         """
-        function_name = name.real_value
+        function_name = cast("str", name.real_value)
+        # If called again with the same args, return the cached value.
+        if (key := (function_name, args)) in self.function_calls:
+            return self.function_calls[key]
         if function_name in predefined_functions:
             try:
-                return predefined_functions[function_name](
+                res = predefined_functions[function_name](
                     *(self.visit(x) for x in (args.children if args else []))  # type: ignore
                 )
+                self.function_calls[key] = res
+                return res
             except TypeError as e:
                 raise EvaluationError(
                     str(e),
@@ -834,7 +797,7 @@ class Filter(Interpreter):
                     end_line=args.meta.end_line if args else name.end_line,
                     end_column=args.meta.end_column if args else name.end_column,
                     end_pos=args.meta.end_pos if args else name.end_pos,
-                )
+                ) from None
         raise EvaluationError(
             f"Function '{name.real_value}' was not found.",
             line=name.line,

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransacklib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 0.1.10
+Version: 0.1.11
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: lark<1.3.0,>=1.2.2
@@ -19,14 +19,10 @@ Requires-Dist: ipranges<0.2,>=0.1.12
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: flake8-pytest-style; extra == "dev"
-Requires-Dist: flake8-bugbear; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: black; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
-Requires-Dist: isort; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

{ransacklib-0.1.10 → ransacklib-0.1.11}/ransacklib.egg-info/requires.txt

@@ -4,11 +4,7 @@ ipranges<0.2,>=0.1.12
 [dev]
 pytest
 pytest-cov
-flake8
-flake8-pytest-style
-flake8-bugbear
 sphinx
 sphinx_rtd_theme
-black
 mypy
-isort
+ruff

{ransacklib-0.1.10 → ransacklib-0.1.11}/tests/test_operator.py

@@ -29,7 +29,7 @@ def test_comp_ip_ip():
     assert _comp_ip_ip(">=", ip3, ip2) is True
     assert _comp_ip_ip("<=", ip1, ip3) is True
     assert _comp_ip_ip("=", ip1, ip1) is True
-    assert _comp_ip_ip("=", ip3, ip1) is False
+    assert _comp_ip_ip("=", ip3, ip1) is True
 
     # Test invalid operator (this branch cannot be reached indirectly)
     with pytest.raises(OperatorNotFoundError) as exc_info:

{ransacklib-0.1.10 → ransacklib-0.1.11}/tests/test_parser.py

@@ -143,33 +143,6 @@ def test_invalid_logical_expression(parser):
         parser.parse_only("a or or b")  # Invalid expression
 
 
-# Test for LIKE operator with valid input
-def test_like_operator(parser):
-    tree = parser.parse_only("Source.IP4 LIKE '192.145.*'")
-    assert tree is not None
-    assert "like_op" in tree.pretty()
-
-
-# Test for LIKE operator case insensitivity
-def test_like_operator_case_insensitive(parser):
-    tree = parser.parse_only('Source.IP4 like "10.0.*"')
-    assert tree is not None
-    assert "like_op" in tree.pretty()
-
-
-# Test for invalid syntax that should raise an error
-def test_invalid_like_syntax(parser):
-    with pytest.raises(ParseError):
-        parser.parse_only("Source.IP4 LIKE 192.145.*")
-
-
-# Test a more complex expression with AND/OR and LIKE
-def test_nested_like_expressions(parser):
-    tree = parser.parse_only('Source.IP4 LIKE "192.145.*" and IP6 like "fe80*"')
-    assert tree is not None
-    assert "and_op" in tree.pretty()
-
-
 # Test for IN operator with a valid list
 def test_in_operator(parser):
     tree = parser.parse_only("Source.Port IN [22, 80, 443]")

{ransacklib-0.1.10 → ransacklib-0.1.11}/tests/test_transformer.py

@@ -4,7 +4,7 @@ import pytest
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 from lark import Token
 
-from ransack.exceptions import EvaluationError, ShapeError
+from ransack.exceptions import RansackError, ShapeError
 from ransack.parser import Parser
 from ransack.transformer import ExpressionTransformer, Filter, TokenWrapper, get_values
 
@@ -39,6 +39,7 @@ sample_data = {
         "SourceResolvedCountry": ["CZ"],
         "StorageTime": "2023-12-12",
         "NestedNullKey": None,
+        "_private": 123,
     },
 }
 
@@ -106,7 +107,6 @@ class TestGetValues:
 
 
 class TestExpressionTransformer:
-
     def parse_and_assert(
         self, parser, expr_transformer, expression, expected_type, expected_value
     ):
@@ -203,19 +203,15 @@ class TestExpressionTransformer:
 
 
 class TestFilter:
-
-    def parse_filter(self, parser, expr_transformer, filter_, expression):
+    def parse_filter(self, parser, filter_, expression):
         """Helper to parse, evaluate atoms to Python object, then evaluate."""
         tree = parser.parse(expression)
-        res = filter_.eval(tree, sample_data)
-        return res
+        return filter_.eval(tree, sample_data)
 
-    def parse_filter_and_expect_error(
-        self, parser, expr_transformer, filter_, expression
-    ):
+    def parse_filter_and_expect_error(self, parser, filter_, expression):
         """Parse the expression and expect an exception to be raised."""
         tree = parser.parse(expression)
-        with pytest.raises(EvaluationError):
+        with pytest.raises(RansackError):
             filter_.eval(tree, sample_data)
 
     @pytest.mark.parametrize(
@@ -330,6 +326,11 @@ class TestFilter:
             ("192.168.1.1 < [192.168.1.0, 192.168.1.1]", False),
             ("192.168.1.1 == [192.168.1.0, 192.168.1.1]", False),
             ("192.168.1.1 = [192.168.1.0, 192.168.1.1]", True),
+            # IP = range
+            ("192.168.0.4 = 192.168.0.1..192.168.0.10", True),
+            ("192.168.0.1-192.168.0.10 = 192.168.0.4", True),
+            ("192.168.0.1-192.168.0.10 = 192.168.0.11", False),
+            ("192.168.0.11 = 192.168.0.1..192.168.0.10", False),
             # Numeric comparisons with tuples
             ("5 > 5..7", False),
             ("5 < 3 .. 6", True),
@@ -378,8 +379,6 @@ class TestFilter:
             ("[192.168.1.1, 192.168.1.3] > 192.168.1.2", True),
             ("192.168.1.2 < [192.168.1.1, 192.168.0.1]", False),
             ("192.168.1.1/32 == 192.168.1.1", True),
-            # Test like operator
-            ("Description like '.*login.*'", True),
             # Test in operator
             ("192.168.0.1 in 192.168.0.0/16", True),
             ("not 192.168.0.1-192.168.0.10 in 192.168.0.8-192.168.0.12", True),
@@ -406,6 +405,13 @@ class TestFilter:
             ("192.168.0.1 in [(192.168.0.0..192.168.0.2)]", True),
             ("2024::10 in [2024::0-2024::10]", True),
             ("2024-12-12 in [(2024-12-01..2024-12-31)]", True),
+            # Test string equality
+            ("'abc' == 'abc'", True),
+            ("'abc' = 'abc'", True),
+            ("'abc' = '_abc_'", False),
+            ("'abc' = ['def', 'abc']", True),
+            ("'abc' = ['a', 'b', 'c']", False),
+            ("['a', 'b', 'c'] = 'b'", True),
             # Test contains operator
             ("'abcdefghi' contains 'def'", True),
             ("not 'abc' contains 'def'", True),
@@ -424,12 +430,15 @@ class TestFilter:
             # Test alternate IP range
             ("192.0.0.1..192.0.0.255", IP4Range("192.0.0.1-192.0.0.255")),
             ("12D3::0 .. 12D3::1", IP6Range("12D3::-12D3::1")),
+            # Test range on variables
+            ("(ConnCount - 5) .. ConnCount", (-4, 1)),
             # Test nested data
             ("ConnCount", 1),
             ("_Mentat.SourceResolvedCountry", ["CZ"]),
             ("Source.IP4", ["1.2.3.235", "1.2.3.236"]),
             ("Credentials.Username", ["root"]),
             ("_Mentat.StorageTime", "2023-12-12"),
+            ("_Mentat._private", 123),
             # Test None is returned
             ("NullKey", None),
             ("_Mentat.NestedNullKey", None),
@@ -451,10 +460,15 @@ class TestFilter:
             ("len([1, 2, 3]) == 3", True),
             ("length([])", 0),
             ("now() > now() - 1D00:00:00", True),
+            ("len(not_in_dict??[])", 0),
+            ("len([1].[2].[3])", 3),
+            # Test that function call returns the same value
+            # when used multipe times in one query
+            ("now() == now()", True),
         ],
     )
-    def test_filters(self, parser, expr_transformer, filter_, expression, expected):
-        result = self.parse_filter(parser, expr_transformer, filter_, expression)
+    def test_filters(self, parser, filter_, expression, expected):
+        result = self.parse_filter(parser, filter_, expression)
         assert result == expected
 
     @pytest.mark.parametrize(
@@ -470,10 +484,9 @@ class TestFilter:
             "len(12)",  # Test wrong type
         ],
     )
-    def test_invalid_cases(self, parser, expr_transformer, filter_, expression):
+    def test_invalid_cases(self, parser, filter_, expression):
         self.parse_filter_and_expect_error(
             parser,
-            expr_transformer,
             filter_,
             expression,
         )