ransacklib 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

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",
 )

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):

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,

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

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.dist-info → ransacklib-0.1.11.dist-info}/METADATA

@@ -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.11.dist-info/RECORD

@@ -0,0 +1,12 @@
+ransack/__init__.py,sha256=l6a6YK8gm6OkFofd_d0VZp3Gxkb7IAmLlqa83oFZ5J8,313
+ransack/exceptions.py,sha256=Ca-r6uQf7Ou-zsQwV3JDqsrEvRVx6Em2Y0ZwZwa1YkI,3732
+ransack/function.py,sha256=u2WR0ZpwETR1MsZCpur680PExeWqH6phQLSTI0DloGI,1080
+ransack/operator.py,sha256=82azEryAMDAwQmCdMPuxdEKFJY46DpuRi639ccuKlLM,16217
+ransack/parser.py,sha256=RuL1whRgm5AhzXX0PrjNevti9fzPL60p_jeC7R15dUs,7230
+ransack/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ransack/transformer.py,sha256=WaIdcZ9xXIbzkOc2v92JdzbmMPKTjxC0ijcTKDjhSfk,27128
+ransacklib-0.1.11.dist-info/licenses/LICENSE,sha256=mUbyu3f_FVAKt9MzuOjDggjsvV-WtwgSPlKPe_xKRBo,1074
+ransacklib-0.1.11.dist-info/METADATA,sha256=kmcFprjAYOXOUVzoIO6I8PG-TK9z-40WgpeluDi0cRI,2715
+ransacklib-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ransacklib-0.1.11.dist-info/top_level.txt,sha256=qVBXu4XHhFMobvS9sDB-r6EQB6hwLQUEiSvX0N7DelM,8
+ransacklib-0.1.11.dist-info/RECORD,,

{ransacklib-0.1.10.dist-info → ransacklib-0.1.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ransacklib-0.1.10.dist-info/RECORD

@@ -1,12 +0,0 @@
-ransack/__init__.py,sha256=QLp0go5FdQXrASgnBNaNKTxEEst54OBWYVG3KgTkVCU,313
-ransack/exceptions.py,sha256=GWV2XlgGYeuGr5I3gPL3vlmakacOg--lAtFCy5iQbsw,3741
-ransack/function.py,sha256=u2WR0ZpwETR1MsZCpur680PExeWqH6phQLSTI0DloGI,1080
-ransack/operator.py,sha256=hpdPNZdSxTqCl6il6j6PZnqMH6HniBCiAdhjqL-dbik,16201
-ransack/parser.py,sha256=aovOrJ4ZKcb0rSn8LJm2GiQZkn9JBaWssAfQ0pj9gUo,7010
-ransack/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ransack/transformer.py,sha256=Ku9DjD3zy4Z1JJduwR_IqqLxmk9BvMct2mmxjzxNaR0,28272
-ransacklib-0.1.10.dist-info/licenses/LICENSE,sha256=mUbyu3f_FVAKt9MzuOjDggjsvV-WtwgSPlKPe_xKRBo,1074
-ransacklib-0.1.10.dist-info/METADATA,sha256=yDcMa86-7G-gME6hHei7GlIzeGRIdENF0NN4tDwhAkk,2887
-ransacklib-0.1.10.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-ransacklib-0.1.10.dist-info/top_level.txt,sha256=qVBXu4XHhFMobvS9sDB-r6EQB6hwLQUEiSvX0N7DelM,8
-ransacklib-0.1.10.dist-info/RECORD,,