ransacklib 1.1.0.dev6__tar.gz → 1.1.0.dev7__tar.gz

{ransacklib-1.1.0.dev6/ransacklib.egg-info → ransacklib-1.1.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev6
+Version: 1.1.0.dev7
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ransacklib"
-version = "1.1.0.dev6"
+version = "1.1.0.dev7"
 description = "A modern, extensible language for manipulation with structured data"
 license = "MIT"
 readme = "README.rst"

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7}/ransack/operator.py

@@ -501,9 +501,40 @@ def binary_operation(operator: str, left: Any, right: Any) -> Any:
 
 
 def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
+    """
+    Maps an expression into its SQL representation.
+
+    Args:
+        op: Operator string (e.g., "=", "+", "and", "contains").
+        l_sql: SQL string representing the left operand.
+        r_sql: SQL string representing the right operand.
+        t1: Resolved type of the left operand.
+        t2: Resolved type of the right operand.
+
+    Returns:
+        A tuple of:
+            - SQL expression string,
+            - result type,
+            - switch flag (True if operands were reversed semantically).
+
+    Raises:
+        KeyError:
+            If no mapping exists for the given operator and operand types.
+    """
+
     def _get_comp_dict_sql(
         op: str, tuple_repr_f
     ) -> dict[tuple[Operand, Operand], tuple[str, bool]]:
+        """
+        Generate comparison operator mappings for multiple type combinations.
+
+        Args:
+            op: SQL comparison operator (e.g., ">", "<=").
+            tuple_repr_f: SQL function name used for tuple bounds (e.g. "lower").
+
+        Returns:
+            Mapping from (type1, type2) -> (SQL string, switch flag).
+        """
         return {
             (Number, Number): (f"{l_sql} {op} {r_sql}", False),
             (Number, list): (f"{l_sql} {op} ANY({r_sql})", False),
@@ -515,10 +546,10 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
             (timedelta, list): (f"{l_sql} {op} ANY({r_sql})", False),
             ("ip", "ip"): (f"{l_sql} {op} {r_sql}", False),
             ("ip", list): (f"{l_sql} {op} ANY({r_sql})", False),
-            # (list, list): f"{l_sql} && {r_sql}",
-            # (tuple, tuple): f"upper({l_sql}) > lower({r_sql})",
         }
 
+    # Comparison and logical operators (result is always boolean).
+    # The boolean flag indicates whether operand order was reversed.
     d: dict[str, dict] = {
         "=": {
             (Number, Number): (f"{l_sql} = {r_sql}", False),
@@ -546,8 +577,16 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
         | {(tuple, tuple): (f"lower({l_sql}) <= upper({r_sql})", False)},
         "and": {(bool, bool): (f"{l_sql} AND {r_sql}", False)},
         "or": {(bool, bool): (f"({l_sql} OR {r_sql})", False)},
-        "contains": {(str, str): (f"position({r_sql} in {l_sql})>0", True)},
+        "contains": {
+            (str, str): (f"position({r_sql} in {l_sql})>0", True),
+            (list, str): (
+                f"position({r_sql} in array_to_string({l_sql}, ','))>0",
+                True,
+            ),
+        },
     }
+
+    # Arithmetic operators (result type varies, operands are not swapped).
     d2: dict[str, dict] = {
         "+": {
             (Number, Number): (f"({l_sql} + {r_sql})", Number),
@@ -572,14 +611,21 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
             (Number, Number): (f"({l_sql} % {r_sql})", Number),
         },
     }
-    if op == "==":
+
+    if op == "==" and t1 == t2:
         return (f"{l_sql} = {r_sql}", bool, False)
+
+    # 'in' operator behaves the same as '=' operator.
     if op == "in":
         sql, switch = d["="][(t1, t2)]
         return sql, bool, switch
+
+    # Arithmetic operator handling.
     if op in d2:
         sql, type_ = d2[op][(t1, t2)]
         return sql, type_, False
+
+    # Default: comparison/logical operator.
     sql, switch = d[op][(t1, t2)]
     return sql, bool, switch
 
@@ -587,6 +633,30 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any, bool]:
 def binary_operation_sql(
     operator: str, left: str, right: str, l_type: Any, r_type: Any
 ) -> tuple[str, bool, Any]:
+    """
+    Converts a binary operation into its SQL equivalent with type handling.
+
+    This function normalizes operand types (e.g., numeric types, IP types),
+    delegates SQL generation to `_operator_map_sql`, and handles operand
+    swapping if needed.
+
+    Args:
+        operator: Operator string (e.g., "+", "=", "in").
+        left: SQL string for the left operand.
+        right: SQL string for the right operand.
+        l_type: Type of the left operand.
+        r_type: Type of the right operand.
+
+    Returns:
+        A tuple of:
+            - SQL expression string,
+            - result type,
+            - switch flag (True if operands were reversed).
+
+    Raises:
+        OperatorNotFoundError:
+            If no valid SQL mapping exists for the operator/type combination.
+    """
     # Normalize numeric types
     l_type = Number if l_type in (int, float) else l_type
     r_type = Number if r_type in (int, float) else r_type

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7}/ransack/parser.py

@@ -12,6 +12,7 @@ Classes:
 """
 
 import os
+from datetime import tzinfo
 from pathlib import Path
 from typing import Any, no_type_check
 
@@ -120,7 +121,11 @@ class Parser:
         %ignore WS
         """  # noqa
 
-    def __init__(self, context: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        context: dict[str, Any] | None = None,
+        default_timezone: tzinfo | None = None,
+    ) -> None:
         """
         Initialize the Parser.
 
@@ -128,6 +133,9 @@ class Parser:
             context (dict[str, Any] | None): Optional dictionary of variables that can
             be referenced in queries. Context variables override data variables unless
             the data variable is explicitly accessed with a leading dot.
+            default_timezone (tzinfo | None): Time zone to apply to parsed datetime
+            values that do not include time zone information. If None, naive datetimes
+            remain naive.
         """
         # 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
@@ -142,7 +150,7 @@ class Parser:
             propagate_positions=True,
             cache=cache_path,
         )
-        self.shaper = ExpressionTransformer(context)
+        self.shaper = ExpressionTransformer(context, default_timezone)
 
     @no_type_check
     def parse(self, data: str) -> Tree[Token]:

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7}/ransack/transformer.py

@@ -20,7 +20,7 @@ Classes:
 
 import re
 from collections.abc import Mapping, MutableSequence
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, tzinfo
 from typing import Any, cast
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
@@ -194,7 +194,11 @@ class ExpressionTransformer(Transformer):
     into appropriate objects (ipranges, datetime, list, ...).
     """
 
-    def __init__(self, context: dict[str, Any] | None = None) -> None:
+    def __init__(
+        self,
+        context: dict[str, Any] | None = None,
+        default_timezone: tzinfo | None = None,
+    ) -> None:
         """
         Initializes the ExpressionTransformer with a context dictionary
         for constants.
@@ -203,8 +207,12 @@ class ExpressionTransformer(Transformer):
             context: A dictionary containing constant values that can be
                      accessed by variable names within expressions.
                      Defaults to an empty dictionary if none is provided.
+            default_timezone: Time zone to apply to parsed datetime values
+                              that do not include time zone information.
+                              If None, naive datetimes remain naive.
         """
         self.context = context if context is not None else {}
+        self.default_timezone = default_timezone
 
     def number(self, data: Token) -> Tree[TokenWrapper]:
         """
@@ -322,6 +330,11 @@ class ExpressionTransformer(Transformer):
 
         # Convert to datetime object
         dtime = datetime.fromisoformat(datetime_str)
+
+        # If no time zone was specified, then set to default time zone
+        if dtime.tzinfo is None:
+            dtime = dtime.replace(tzinfo=self.default_timezone)
+
         tw = TokenWrapper(_add_tokens(date, time), dtime)
 
         return Tree("datetime", [tw], _create_meta(tw))
@@ -337,7 +350,14 @@ class ExpressionTransformer(Transformer):
         """
         return Tree(
             "datetime",
-            [TokenWrapper(date, datetime.fromisoformat(date + "T00:00:00"))],
+            [
+                TokenWrapper(
+                    date,
+                    datetime.fromisoformat(date + "T00:00:00").replace(
+                        tzinfo=self.default_timezone
+                    ),
+                )
+            ],
             _create_meta(date),
         )
 
@@ -819,7 +839,8 @@ class SQLInterpreter(Interpreter):
             data: Optional dictionary containing the definition of queried columns.
 
         Returns:
-            A part of the SQL query - the part after 'SELECT' or 'WHERE'.
+            A part of the SQL query (the part after 'SELECT' or 'WHERE') and its
+            parameters.
         """
         self.data = data if data is not None else {}
 
@@ -867,7 +888,7 @@ class SQLInterpreter(Interpreter):
         elif issubclass(l_type, float) and issubclass(r_type, float):
             range_type = "numrange"
         elif issubclass(l_type, datetime) and issubclass(r_type, datetime):
-            if "WITH TIME ZONE" in l_sql or "WITH TIME ZONE" in r_sql:
+            if "WITH TIME ZONE" in l_sql and "WITH TIME ZONE" in r_sql:
                 range_type = "tstzrange"
             else:
                 range_type = "tsrange"
@@ -879,7 +900,7 @@ class SQLInterpreter(Interpreter):
             )
         else:
             raise EvaluationError(
-                f"Range operator is not supported for types '{l_type}' and '{r_type}'",
+                f"Range operator is not supported for types '{l_type}' and '{r_type}'.",
                 line=l_tree.meta.line,
                 column=l_tree.meta.column,
                 start_pos=l_tree.meta.start_pos,
@@ -903,7 +924,7 @@ class SQLInterpreter(Interpreter):
             column, type_ = self.data[var.real_value]
             return (f'"{column}"', [], type_)
         raise EvaluationError(
-            f"The type of column '{var.real_value}' was not defined",
+            f"The type of column '{var.real_value}' was not defined.",
             line=var.line,
             column=var.column,
             start_pos=var.start_pos,
@@ -988,14 +1009,21 @@ class SQLInterpreter(Interpreter):
 
         args_sql = []
         params = []
+        types = []
 
         for arg in args.children if args else []:
-            sql, p, _ = self.visit(arg)
+            sql, p, type_ = self.visit(arg)
             args_sql.append(sql)
             params.extend(p)
-
-        if function_name == "now":
-            return "localtimestamp", [], datetime
+            types.append(type_)
+
+        if function_name == "now" and len(args_sql) == 0:
+            return "localtimestamp", params, datetime
+        if function_name in ("len", "length") and len(args_sql) == 1:
+            if types[0] is list:
+                return f"array_length({args_sql[0]}, 1)", params, int
+            if types[0] is str:
+                return f"length({args_sql[0]})", params, int
         raise EvaluationError(
             f"Function '{name.real_value}' was not found.",
             line=name.line,

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7/ransacklib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev6
+Version: 1.1.0.dev7
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT

{ransacklib-1.1.0.dev6 → ransacklib-1.1.0.dev7}/tests/test_transformer.py

@@ -213,6 +213,68 @@ class TestExpressionTransformer:
         assert result_data.children[0].real_value == "my_var"
 
 
+class TestDefaultTimezone:
+    def test_naive_datetime_gets_default_timezone(self):
+        parser = Parser(default_timezone=timezone.utc)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo == timezone.utc
+        assert str(result) == "2024-01-01 12:00:00+00:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo == timezone.utc
+        assert str(result) == "2024-01-01 00:00:00+00:00"
+
+    def test_naive_datetime_with_custom_timezone(self):
+        custom_tz = timezone(timedelta(hours=2))
+        parser = Parser(default_timezone=custom_tz)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo == custom_tz
+        assert str(result) == "2024-01-01 12:00:00+02:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo == custom_tz
+        assert str(result) == "2024-01-01 00:00:00+02:00"
+
+    def test_datetime_with_timezone_not_overridden(self):
+        parser = Parser(default_timezone=timezone.utc)
+
+        result = parser.parse("2024-01-01T12:00:00+02:00").children[0].real_value
+
+        # Should keep original timezone
+        assert result.tzinfo.utcoffset(result) == timedelta(hours=2)
+        assert str(result) == "2024-01-01 12:00:00+02:00"
+
+    def test_no_default_timezone_keeps_naive_datetime(self):
+        parser = Parser(default_timezone=None)
+
+        result = parser.parse("2024-01-01T12:00:00").children[0].real_value
+
+        assert result.tzinfo is None
+        assert str(result) == "2024-01-01 12:00:00"
+
+        result = parser.parse("2024-01-01").children[0].real_value
+
+        assert result.tzinfo is None
+        assert str(result) == "2024-01-01 00:00:00"
+
+    def test_expression_transformer_default_timezone_direct(self, parser):
+        transformer = ExpressionTransformer(default_timezone=timezone.utc)
+
+        result = (
+            transformer.transform(parser.parse_only("2024-01-01T12:00:00"))
+            .children[0]
+            .real_value
+        )
+
+        assert result.tzinfo == timezone.utc
+
+
 class TestFilter:
     def parse_filter(self, parser, filter_, expression):
         """Helper to parse, evaluate atoms to Python object, then evaluate."""
@@ -522,6 +584,7 @@ class TestSQLInterpreter:
             "c_int": ("c", int),
             "d_int": ("d", int),
             "Description": ("description", str),
+            "Category": ("category", list),
         }
         return sql.to_sql(tree, data)
 
@@ -676,6 +739,16 @@ class TestSQLInterpreter:
             ("a_int??14", 'COALESCE("a", %s)', [14]),
             # Test contains operator.
             ("'abcdfg' contains 'bcd'", "position(%s in %s)>0", ["bcd", "abcdfg"]),
+            (
+                "Category contains 'Attempt'",
+                "position(%s in array_to_string(\"category\", ','))>0",
+                ["Attempt"],
+            ),
+            (
+                "['abcdfg', 'qwerty', 'azerty'] contains 'bcd'",
+                "position(%s in array_to_string(ARRAY[%s, %s, %s], ','))>0",
+                ["bcd", "abcdfg", "qwerty", "azerty"],
+            ),
             # Test = operator.
             ("1 = 1", "%s = %s", [1, 1]),
             ("1 = [1, 2, 3]", "%s = ANY(ARRAY[%s, %s, %s])", [1, 1, 2, 3]),
@@ -762,6 +835,20 @@ class TestSQLInterpreter:
                     from_str("192.168.0.0/16"),
                 ],
             ),
+            # Test functions.
+            (
+                "now() > 2025-12-12T12:34:56Z",
+                "localtimestamp > %s::TIMESTAMP WITH TIME ZONE",
+                [datetime(2025, 12, 12, 12, 34, 56, tzinfo=timezone.utc)],
+            ),
+            ("length('')", "length(%s)", [""]),
+            ("length('abcde')", "length(%s)", ["abcde"]),
+            (
+                "length([1, 2, 3]) == 3",
+                "array_length(ARRAY[%s, %s, %s], 1) = %s",
+                [1, 2, 3, 3],
+            ),
+            ("len(Category) > 1", 'array_length("category", 1) > %s', [1]),
         ],
     )
     def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):