ransacklib 1.1.0.dev1__tar.gz → 1.1.0.dev3__tar.gz

{ransacklib-1.1.0.dev1/ransacklib.egg-info → ransacklib-1.1.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev1
+Version: 1.1.0.dev3
 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.dev1 → ransacklib-1.1.0.dev3}/pyproject.toml

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

{ransacklib-1.1.0.dev1 → ransacklib-1.1.0.dev3}/ransack/operator.py

@@ -546,10 +546,36 @@ def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any]:
         "or": {(bool, bool): f"{l_sql} OR {r_sql}"},
         "contains": {(str, str): f"position({r_sql} in {l_sql})>0"},
     }
+    d2: dict[str, dict] = {
+        "+": {
+            (Number, Number): (f"{l_sql} + {r_sql}", Number),
+            (datetime, timedelta): (f"{l_sql} + {r_sql}", datetime),
+            (timedelta, timedelta): (f"{l_sql} + {r_sql}", timedelta),
+        },
+        "-": {
+            (Number, Number): (f"{l_sql} - {r_sql}", Number),
+            (datetime, timedelta): (f"{l_sql} - {r_sql}", datetime),
+            (timedelta, timedelta): (f"{l_sql} - {r_sql}", timedelta),
+            (datetime, datetime): (f"{l_sql} - {r_sql}", timedelta),
+        },
+        "*": {
+            (timedelta, Number): (f"{l_sql} * {r_sql}", timedelta),
+            (Number, Number): (f"{l_sql} * {r_sql}", Number),
+        },
+        "/": {
+            (timedelta, timedelta): (f"{l_sql} / {r_sql}", timedelta),
+            (Number, Number): (f"{l_sql} / {r_sql}", Number),
+        },
+        "%": {
+            (Number, Number): (f"{l_sql} % {r_sql}", timedelta),
+        },
+    }
     if op == "==":
         return (f"{l_sql} = {r_sql}", bool)
     if op == "in":
         return (d["="][(t1, t2)], bool)
+    if op in d2:
+        return d2[op][(t1, t2)]
     return (d[op][(t1, t2)], bool)
 
 

{ransacklib-1.1.0.dev1 → ransacklib-1.1.0.dev3}/ransack/transformer.py

@@ -20,7 +20,7 @@ Classes:
 
 import re
 from collections.abc import Mapping, MutableSequence
-from datetime import datetime, timedelta, timezone
+from datetime import datetime, timedelta
 from typing import Any, cast
 
 from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
@@ -322,27 +322,22 @@ class ExpressionTransformer(Transformer):
 
         # Convert to datetime object
         dtime = datetime.fromisoformat(datetime_str)
-
-        # If no time zone was specified, then set to UTC
-        if dtime.tzinfo is None:
-            dtime = dtime.replace(tzinfo=timezone.utc)
-
         tw = TokenWrapper(_add_tokens(date, time), dtime)
 
         return Tree("datetime", [tw], _create_meta(tw))
 
     def datetime_only_date(self, date: Token) -> Tree[TokenWrapper]:
         """
-        Transforms a date string into a datetime object set to midnight UTC.
+        Transforms a date string into a datetime object set to midnight.
 
         Parameters:
             date: A token representing the date.
         Returns:
-            A tree node wrapping a datetime object set to midnight UTC.
+            A tree node wrapping a datetime object set to midnight.
         """
         return Tree(
             "datetime",
-            [TokenWrapper(date, datetime.fromisoformat(date + "T00:00:00+00:00"))],
+            [TokenWrapper(date, datetime.fromisoformat(date + "T00:00:00"))],
             _create_meta(date),
         )
 
@@ -837,9 +832,12 @@ class SQLInterpreter(Interpreter):
         return (str(token.real_value), type(token.real_value))
 
     def datetime(self, token: TokenWrapper) -> tuple[str, type[datetime]]:
-        # When using 'real_value', the time zone is always defined
+        if token.real_value.tzinfo is not None:
+            type_ = "TIMESTAMP WITH TIME ZONE"
+        else:
+            type_ = "TIMESTAMP"
         return (
-            f"TIMESTAMP WITH TIME ZONE '{token.real_value.isoformat()}'",
+            f"{type_} '{token.real_value.isoformat()}'",
             type(token.real_value),
         )
 
@@ -877,7 +875,10 @@ 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):
-            range_type = "tstzrange"
+            if "WITH TIME ZONE" in l_sql or "WITH TIME ZONE" in r_sql:
+                range_type = "tstzrange"
+            else:
+                range_type = "tsrange"
         elif issubclass(l_type, (IP4, IP6)) and issubclass(r_type, (IP4, IP6)):
             return (
                 f"iprange({l_sql}, {r_sql})",
@@ -923,6 +924,21 @@ class SQLInterpreter(Interpreter):
 
         return binary_operation_sql(operator, l_sql, r_sql, l_type, r_type)
 
+    def add(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+        return self._binary_operation("+", l_tree, r_tree)
+
+    def sub(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+        return self._binary_operation("-", l_tree, r_tree)
+
+    def mul(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+        return self._binary_operation("*", l_tree, r_tree)
+
+    def div(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+        return self._binary_operation("/", l_tree, r_tree)
+
+    def mod(self, l_tree: Tree, r_tree: Tree) -> tuple[str, Any]:
+        return self._binary_operation("-", l_tree, r_tree)
+
     def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
         return self._binary_operation("==", l_tree, r_tree)
 
@@ -965,3 +981,18 @@ class SQLInterpreter(Interpreter):
         var, _ = self.var_from_data(TokenWrapper(path, path))
         sql, type_ = self.visit(default)
         return f"COALESCE({var!s}, {sql})", type_
+
+    def function_(self, name: TokenWrapper, args: Tree | None) -> tuple[str, Any]:
+        function_name = cast("str", name.real_value)
+        args = [self.visit(x) for x in (args.children if args else [])]  # type: ignore
+        if function_name == "now":
+            return "localtimestamp", datetime
+        raise EvaluationError(
+            f"Function '{name.real_value}' was not found.",
+            line=name.line,
+            column=name.column,
+            start_pos=name.start_pos,
+            end_line=name.end_line,
+            end_column=name.end_column,
+            end_pos=name.end_pos,
+        )

{ransacklib-1.1.0.dev1 → ransacklib-1.1.0.dev3/ransacklib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 1.1.0.dev1
+Version: 1.1.0.dev3
 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.dev1 → ransacklib-1.1.0.dev3}/tests/test_transformer.py

@@ -150,7 +150,7 @@ class TestExpressionTransformer:
             ),
             ("2024-01-01T12:00:00Z", datetime, "2024-01-01 12:00:00+00:00"),
             ("2024-01-01 12:00:00-02:00", datetime, "2024-01-01 12:00:00-02:00"),
-            ("2024-01-01T12:00:00", datetime, "2024-01-01 12:00:00+00:00"),
+            ("2024-01-01T12:00:00", datetime, "2024-01-01 12:00:00"),
             ("01:00:00", timedelta, "1:00:00"),
             ("1d01:00:00", timedelta, "1 day, 1:00:00"),
             ("'constant1'", str, "constant1"),
@@ -233,11 +233,11 @@ class TestFilter:
             ("(4 + 5 * 2 - 6 / 3) % 5", 2),
             (
                 "2024-01-01 - 1D00:00:00",
-                datetime.fromisoformat("2023-12-31T00:00:00+00:00"),
+                datetime.fromisoformat("2023-12-31T00:00:00"),
             ),
             (
                 "2023-11-28 15:30:00 + 0D10:00:00",
-                datetime.fromisoformat("2023-11-29T01:30:00+00:00"),
+                datetime.fromisoformat("2023-11-29T01:30:00"),
             ),
             ("3D00:00:00 + 0D05:00:00", timedelta(days=3, hours=5)),
             ("0D10:00:00 + 0D00:20:00", timedelta(hours=10, minutes=20)),
@@ -249,15 +249,15 @@ class TestFilter:
             (
                 "1D00:00:00 + 2024-02-28..2025-02-28",
                 (
-                    datetime.fromisoformat("2024-02-29T00:00:00+00:00"),
-                    datetime.fromisoformat("2025-03-01T00:00:00+00:00"),
+                    datetime.fromisoformat("2024-02-29T00:00:00"),
+                    datetime.fromisoformat("2025-03-01T00:00:00"),
                 ),
             ),
             (
                 "2024-01-01 .. 2024-12-31 - 1D00:00:00",
                 (
-                    datetime.fromisoformat("2023-12-31T00:00:00+00:00"),
-                    datetime.fromisoformat("2024-12-30T00:00:00+00:00"),
+                    datetime.fromisoformat("2023-12-31T00:00:00"),
+                    datetime.fromisoformat("2024-12-30T00:00:00"),
                 ),
             ),
             # Scalar and list
@@ -286,8 +286,8 @@ class TestFilter:
             (
                 "2023-11-28 + [1D00:00:00, 2D00:00:00]",
                 [
-                    datetime.fromisoformat("2023-11-29T00:00:00+00:00"),
-                    datetime.fromisoformat("2023-11-30T00:00:00+00:00"),
+                    datetime.fromisoformat("2023-11-29T00:00:00"),
+                    datetime.fromisoformat("2023-11-30T00:00:00"),
                 ],
             ),
             # Test Comparisons
@@ -534,7 +534,7 @@ class TestSQLInterpreter:
             ("23.22", "23.22"),
             ("-0.224", "-0.224"),
             ("13e19", "1.3e+20"),
-            ("2025-01-01", "TIMESTAMP WITH TIME ZONE '2025-01-01T00:00:00+00:00'"),
+            ("2025-01-01", "TIMESTAMP '2025-01-01T00:00:00'"),
             (
                 "2025-01-01T22:14:24.142+02:00",
                 "TIMESTAMP WITH TIME ZONE '2025-01-01T22:14:24.142000+02:00'",
@@ -554,8 +554,8 @@ class TestSQLInterpreter:
             (
                 "[2024-12-12, 2025-12-12]",
                 (
-                    "ARRAY[TIMESTAMP WITH TIME ZONE '2024-12-12T00:00:00+00:00', "
-                    "TIMESTAMP WITH TIME ZONE '2025-12-12T00:00:00+00:00']"
+                    "ARRAY[TIMESTAMP '2024-12-12T00:00:00', "
+                    "TIMESTAMP '2025-12-12T00:00:00']"
                 ),
             ),
             ("[]", "ARRAY[]"),
@@ -584,7 +584,7 @@ class TestSQLInterpreter:
                 ),
             ),
             (
-                "2024-01-01..2024-12-31",
+                "2024-01-01T00:00:00+00:00..2024-12-31T00:00:00Z",
                 (
                     "CASE WHEN TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00' "
                     "< TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00' THEN "