ransacklib 1.1.0.dev14__tar.gz → 1.1.0.dev15__tar.gz

{ransacklib-1.1.0.dev14/ransacklib.egg-info → ransacklib-1.1.0.dev15}/PKG-INFO

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

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

{ransacklib-1.1.0.dev14 → ransacklib-1.1.0.dev15}/ransack/transformer.py

@@ -871,12 +871,7 @@ class SQLInterpreter(Interpreter):
         return ("%s", [token.real_value], types.String)
 
     def ip(self, token: TokenWrapper) -> tuple[str, list, types.RansackType]:
-        match token.real_value:
-            case IP4() | IP6():
-                cast = "ipaddress"
-            case IP4Range() | IP6Range() | IP4Net() | IP6Net():
-                cast = "iprange"
-        return (f"%s::{cast}", [token.real_value], types.IP)
+        return ("%s::iprange", [token.real_value], types.IP)
 
     def neg(self, tree: Tree) -> tuple[str, list, Any]:
         sql, params, type_ = self.visit(tree)
@@ -903,7 +898,7 @@ class SQLInterpreter(Interpreter):
                 range_type = "tsrange"
         elif l_type is types.IP and r_type is types.IP:
             return (
-                f"iprange({l_sql}, {r_sql})",
+                f"iprange({l_sql}::text::ipaddress, {r_sql}::text::ipaddress)",
                 l_params + r_params,
                 types.IP,
             )

{ransacklib-1.1.0.dev14 → ransacklib-1.1.0.dev15/ransacklib.egg-info}/PKG-INFO

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

@@ -2,9 +2,10 @@ from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
 
 import pytest
+from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 from psycopg.types.range import Range
 
-from ransack import Parser, SQLInterpreter, types
+from ransack import Parser, RansackError, SQLInterpreter, types
 
 
 @pytest.fixture
@@ -27,9 +28,11 @@ def test_data(db):
                 ts_value        timestamp,
                 tstz_value      timestamptz,
                 interval_value  interval,
+                ip_value        iprange,
 
                 int_array       integer[],
                 text_array      text[],
+                iprange_array   iprange[],
                 interval_array  interval[],
                 null_array      integer[]
             );
@@ -39,8 +42,8 @@ def test_data(db):
             f"""
             INSERT INTO {table}
             VALUES (
-                %s, %s, %s, %s, %s, %s, %s, %s, %s,
-                %s, %s, %s, %s
+                %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,
+                %s, %s, %s, %s, %s
             )
             """,
             (
@@ -53,8 +56,10 @@ def test_data(db):
                 datetime(2025, 1, 1, 12, 0, 0),
                 datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone.utc),
                 timedelta(days=2, seconds=123),
+                IP4("192.168.1.120"),
                 [1, 2, 3],
                 ["a", "b", "c"],
+                [IP4("192.168.0.1"), IP4("192.168.0.20"), IP4Net("192.168.1.0/24")],
                 [
                     timedelta(hours=1),
                     timedelta(hours=2),
@@ -83,8 +88,10 @@ def ransack_sql_mapping():
         "creation_time": ("ts_value", types.Datetime),
         "detection_time": ("tstz_value", types.Datetime),
         "delta": ("interval_value", types.Timedelta),
+        "source_ip": ("ip_value", types.IP),
         "ports": ("int_array", types.List[types.Number]),
         "categories": ("text_array", types.List[types.String]),
+        "iprange_array": ("iprange_array", types.List(types.IP)),
         "deltas": ("interval_array", types.List[types.Timedelta]),
         "null_array": ("null_array", types.List[types.Number]),
     }
@@ -135,6 +142,13 @@ def test_connection(db):
         ("''", ""),
         ('"string"', "string"),
         ('"\';DROP TABLE USERS"', "';DROP TABLE USERS"),
+        # IP.
+        ("192.168.0.0", IP4("192.168.0.0")),
+        ("192.168.0.0/16", IP4Net("192.168.0.0/16")),
+        ("192.168.0.10-192.168.0.50", IP4Range("192.168.0.10-192.168.0.50")),
+        ("fd00::1", IP6("fd00::1")),
+        ("fd00::/8", IP6Net("fd00::/8")),
+        ("fd00::1-fd00::10", IP6Range("fd00::1-fd00::10")),
     ],
 )
 def test_basic_types(db, expr, expected):
@@ -152,6 +166,19 @@ def test_basic_types(db, expr, expected):
         ("[1, 2, 3]", [1, 2, 3]),
         ("[01:23:34]", [timedelta(seconds=5014)]),
         ('[["a"]]', [["a"]]),
+        ("[192.168.0.0, 192.168.0.1]", [IP4("192.168.0.0"), IP4("192.168.0.1")]),
+        (
+            "[192.168.0.0, 192.168.0.0/16, 192.168.0.10-192.168.0.50]",
+            [
+                IP4("192.168.0.0"),
+                IP4Net("192.168.0.0/16"),
+                IP4Range("192.168.0.10-192.168.0.50"),
+            ],
+        ),
+        (
+            "[fd00::1, fd00::/8, fd00::1-fd00::10]",
+            [IP6("fd00::1"), IP6Net("fd00::/8"), IP6Range("fd00::1-fd00::10")],
+        ),
         # Ranges.
         ("100..1", Range(1, 101, "[)")),
         ("100.12..1.14", Range(1.14, 100.12, "[]")),
@@ -175,6 +202,8 @@ def test_basic_types(db, expr, expected):
                 "[]",
             ),
         ),
+        ("192.168.0.10..192.168.0.50", IP4Range("192.168.0.10-192.168.0.50")),
+        ("fd00::1..fd00::10", IP6Range("fd00::1-fd00::10")),
     ],
 )
 def test_container_types(db, expr, expected):
@@ -195,8 +224,13 @@ def test_container_types(db, expr, expected):
         ("creation_time", datetime(2025, 1, 1, 12, 0)),
         ("detection_time", datetime(2025, 1, 1, 12, 0, tzinfo=ZoneInfo(key="Etc/UTC"))),
         ("delta", timedelta(days=2, seconds=123)),
+        ("source_ip", IP4("192.168.1.120")),
         ("ports", [1, 2, 3]),
         ("categories", ["a", "b", "c"]),
+        (
+            "iprange_array",
+            [IP4("192.168.0.1"), IP4("192.168.0.20"), IP4Net("192.168.1.0/24")],
+        ),
         ("deltas", [timedelta(seconds=3600), timedelta(seconds=7200)]),
         ("[a_int, b_int]", [12, -200]),
         ("a_int..b_int", Range(-200, 13, "[)")),
@@ -303,6 +337,7 @@ def test_concat_operator(db, expr, expected, test_data, ransack_sql_mapping):
         ("len(ports)", 3),
         ("len(categories)", 3),
         ("length([0, 1, 2, 3])", 4),
+        ("length(iprange_array)", 3),
     ],
 )
 def test_functions(db, expr, expected, test_data, ransack_sql_mapping):
@@ -897,6 +932,24 @@ def test_any_equal_operator(db, expr, expected):
         ("delta = [01:00:00]", False),
         ("01:00:00 = deltas", True),
         ("03:00:00 = deltas", False),
+        # IP = IP
+        ("10.10.10.10 = 10.10.10.10", True),
+        ("10.10.10.10 = 10.10.10.0 .. 10.10.10.20", True),
+        ("192.168.0.5 = 192.168.0.0-192.168.0.255", True),
+        ("192.168.0.12 = 192.168.1.0/24", False),
+        ("10.10.10.10-10.10.10.20 = 10.10.10.15-10.10.10.25", True),
+        ("10.10.10.10-10.10.10.20 = 192.168.0.0/16", False),
+        ("192.168.1.0/24 = 192.168.0.0/16", True),
+        # IP = List[IP]
+        ("192.168.1.10 = [192.168.0.0/24, 192.168.0.0/16]", True),
+        ("192.168.1.10 = [10.0.0.0/8, 172.16.0.0/12]", False),
+        ("2001:db8::1 = [2001:db8:1::/48, 2001:db8::/32]", True),
+        ("2001:db8::1 = [fd00::/8, fe80::/10]", False),
+        # List[IP] = IP
+        ("[192.168.0.0/24, 192.168.0.0/16] = 192.168.1.10", True),
+        ("[10.0.0.0/8, 172.16.0.0/12] = 192.168.1.10", False),
+        ("[2001:db8:1::/48, 2001:db8::/32] = 2001:db8::1", True),
+        ("[fd00::/8, fe80::/10] = 2001:db8::1", False),
         # List = List (overlap).
         ("ports = [3, 4, 5]", True),
         ("ports = [4, 5]", False),
@@ -992,6 +1045,57 @@ def test_any_equal_operator_variables(
         ("01:00:00 >= 01:00:00", True),
         ("01:00:00 < 02:00:00", True),
         ("01:00:00 <= 01:00:00", True),
+        # IP x IP.
+        ("10.0.0.2 > 10.0.0.1", True),
+        ("10.0.0.1 > 10.0.0.2", False),
+        ("10.0.0.1 >= 10.0.0.1", True),
+        ("10.0.0.1 >= 10.0.0.2", False),
+        ("10.0.0.1 < 10.0.0.2", True),
+        ("10.0.0.2 < 10.0.0.1", False),
+        ("10.0.0.1 <= 10.0.0.1", True),
+        ("10.0.0.2 <= 10.0.0.1", False),
+        ("2001:db8::2 > 2001:db8::1", True),
+        ("2001:db8::1 > 2001:db8::2", False),
+        ("2001:db8::1 >= 2001:db8::1", True),
+        ("2001:db8::1 >= 2001:db8::2", False),
+        ("2001:db8::1 < 2001:db8::2", True),
+        ("2001:db8::2 < 2001:db8::1", False),
+        ("2001:db8::1 <= 2001:db8::1", True),
+        ("2001:db8::2 <= 2001:db8::1", False),
+        # IP x List(IP).
+        ("10.0.0.5 > [10.0.0.1, 10.0.0.10]", True),
+        ("10.0.0.0 > [10.0.0.1, 10.0.0.10]", False),
+        ("10.0.0.5 >= [10.0.0.5, 10.0.0.10]", True),
+        ("10.0.0.4 >= [10.0.0.5, 10.0.0.10]", False),
+        ("10.0.0.5 < [10.0.0.1, 10.0.0.10]", True),
+        ("10.0.0.20 < [10.0.0.1, 10.0.0.10]", False),
+        ("10.0.0.5 <= [10.0.0.1, 10.0.0.5]", True),
+        ("10.0.0.20 <= [10.0.0.1, 10.0.0.5]", False),
+        ("2001:db8::5 > [2001:db8::1, 2001:db8::10]", True),
+        ("2001:db8::0 > [2001:db8::1, 2001:db8::10]", False),
+        ("2001:db8::5 >= [2001:db8::5, 2001:db8::10]", True),
+        ("2001:db8::4 >= [2001:db8::5, 2001:db8::10]", False),
+        ("2001:db8::5 < [2001:db8::1, 2001:db8::10]", True),
+        ("2001:db8::20 < [2001:db8::1, 2001:db8::10]", False),
+        ("2001:db8::5 <= [2001:db8::1, 2001:db8::5]", True),
+        ("2001:db8::20 <= [2001:db8::1, 2001:db8::5]", False),
+        # List(IP) x IP.
+        ("[10.0.0.1, 10.0.0.10] > 10.0.0.5", True),
+        ("[10.0.0.1, 10.0.0.2] > 10.0.0.5", False),
+        ("[10.0.0.5, 10.0.0.10] >= 10.0.0.5", True),
+        ("[10.0.0.1, 10.0.0.2] >= 10.0.0.5", False),
+        ("[10.0.0.1, 10.0.0.10] < 10.0.0.5", True),
+        ("[10.0.0.10, 10.0.0.20] < 10.0.0.5", False),
+        ("[10.0.0.1, 10.0.0.5] <= 10.0.0.5", True),
+        ("[10.0.0.10, 10.0.0.20] <= 10.0.0.5", False),
+        ("[2001:db8::1, 2001:db8::10] > 2001:db8::5", True),
+        ("[2001:db8::1, 2001:db8::2] > 2001:db8::5", False),
+        ("[2001:db8::5, 2001:db8::10] >= 2001:db8::5", True),
+        ("[2001:db8::1, 2001:db8::2] >= 2001:db8::5", False),
+        ("[2001:db8::1, 2001:db8::10] < 2001:db8::5", True),
+        ("[2001:db8::10, 2001:db8::20] < 2001:db8::5", False),
+        ("[2001:db8::1, 2001:db8::5] <= 2001:db8::5", True),
+        ("[2001:db8::10, 2001:db8::20] <= 2001:db8::5", False),
         # Empty arrays.
         ("1 > []", False),
         ("1 >= []", False),
@@ -1176,3 +1280,21 @@ def test_complex_expressions(
             params,
         )
         assert cur.fetchone()[0] is expected
+
+
+@pytest.mark.sql
+@pytest.mark.parametrize(
+    ("expr"),
+    [
+        "2000-12-24..192.168.0.50",  # Unsupported type of range.
+        "1..1.5",
+        "1..2025-01-01",
+        '"abc"..123',
+        "01:00:00..5",
+        "not_there",  # Unknown column.
+    ],
+)
+def test_invalid_cases(expr):
+    tree = Parser().parse(expr)
+    with pytest.raises(RansackError):
+        SQLInterpreter().to_sql(tree)

{ransacklib-1.1.0.dev14 → ransacklib-1.1.0.dev15}/tests/test_transformer.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta, timezone
 
 import pytest
-from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range, from_str
+from ipranges import IP4, IP6, IP4Net, IP4Range, IP6Net, IP6Range
 from lark import Token
 
 from ransack.exceptions import RansackError, ShapeError
@@ -13,7 +13,6 @@ from ransack.transformer import (
     TokenWrapper,
     get_values,
 )
-from ransack.types import Integer, List, String
 
 
 @pytest.fixture
@@ -574,124 +573,3 @@ class TestFilter:
         exp_tree = expr_transformer.transform(parser.parse_only("my_var == 14"))
         res = filter_.transform(exp_tree)
         assert res
-
-
-class TestSQLInterpreter:
-    def parse(self, parser, sql, expression):
-        tree = parser.parse(expression)
-        data = {
-            "a_int": ("a", Integer),
-            "b_int": ("b", Integer),
-            "c_int": ("c", Integer),
-            "d_int": ("d", Integer),
-            "Description": ("description", String),
-            "Category": ("category", List[String]),
-        }
-        return sql.to_sql(tree, data)
-
-    @pytest.mark.parametrize(
-        ("expr", "expected_sql", "expected_params"),
-        [
-            # IPs.
-            ("192.168.0.0", "%s::ipaddress", [from_str("192.168.0.0")]),
-            ("192.168.0.0/16", "%s::iprange", [from_str("192.168.0.0/16")]),
-            (
-                "192.168.0.10-192.168.0.50",
-                "%s::iprange",
-                [from_str("192.168.0.10-192.168.0.50")],
-            ),
-            ("fd00::1", "%s::ipaddress", [from_str("fd00::1")]),
-            ("fd00::/8", "%s::iprange", [from_str("fd00::/8")]),
-            ("fd00::1-fd00::10", "%s::iprange", [from_str("fd00::1-fd00::10")]),
-            (
-                "192.168.0.10..192.168.0.50",
-                "iprange(%s::ipaddress, %s::ipaddress)",
-                [from_str("192.168.0.10"), from_str("192.168.0.50")],
-            ),
-            (
-                "fd00::1..fd00::10",
-                "iprange(%s::ipaddress, %s::ipaddress)",
-                [from_str("fd00::1"), from_str("fd00::10")],
-            ),
-            # Test = operator.
-            (
-                "10.10.10.10 = 10.10.10.10",
-                "%s::ipaddress && %s::ipaddress",
-                [from_str("10.10.10.10"), from_str("10.10.10.10")],
-            ),
-            (
-                "10.10.10.10 = 10.10.10.0 .. 10.10.10.20",
-                "%s::ipaddress && iprange(%s::ipaddress, %s::ipaddress)",
-                [
-                    from_str("10.10.10.10"),
-                    from_str("10.10.10.0"),
-                    from_str("10.10.10.20"),
-                ],
-            ),
-            (
-                "192.168.0.5 = 192.168.0.0-192.168.0.255",
-                "%s::ipaddress && %s::iprange",
-                [from_str("192.168.0.5"), from_str("192.168.0.0-192.168.0.255")],
-            ),
-            (
-                "192.168.0.12 = 192.168.1.0/24",
-                "%s::ipaddress && %s::iprange",
-                [from_str("192.168.0.12"), from_str("192.168.1.0/24")],
-            ),
-            (
-                "10.10.10.10-10.10.10.20 = 10.10.10.15-10.10.10.25",
-                "%s::iprange && %s::iprange",
-                [
-                    from_str("10.10.10.10-10.10.10.20"),
-                    from_str("10.10.10.15-10.10.10.25"),
-                ],
-            ),
-            (
-                "10.10.10.10-10.10.10.20 = 192.168.0.0/16",
-                "%s::iprange && %s::iprange",
-                [from_str("10.10.10.10-10.10.10.20"), from_str("192.168.0.0/16")],
-            ),
-            (
-                "192.168.1.0/24 = 192.168.0.0/16",
-                "%s::iprange && %s::iprange",
-                [from_str("192.168.1.0/24"), from_str("192.168.0.0/16")],
-            ),
-            (
-                "192.168.1.10 = [192.168.0.0/24, 192.168.0.0/16]",
-                ("%s::ipaddress && ANY(ARRAY[%s::iprange, %s::iprange])"),
-                [
-                    from_str("192.168.1.10"),
-                    from_str("192.168.0.0/24"),
-                    from_str("192.168.0.0/16"),
-                ],
-            ),
-        ],
-    )
-    def test_parse_sql(self, parser, sql, expr, expected_sql, expected_params):
-        sql_str, params, _ = self.parse(parser, sql, expr)
-
-        assert sql_str == expected_sql
-        assert params == expected_params
-
-    def to_sql_and_expect_error(self, parser, sql, expression):
-        tree = parser.parse(expression)
-        with pytest.raises(RansackError):
-            sql.to_sql(tree)
-
-    @pytest.mark.parametrize(
-        "expression",
-        [
-            "2000-12-24..192.168.0.50",  # Unsupported type of range.
-            "1..1.5",
-            "1..2025-01-01",
-            '"abc"..123',
-            "01:00:00..5",
-            "not_there",  # Unknown column.
-        ],
-    )
-    def test_invalid_cases(self, parser, sql, expression):
-        self.to_sql_and_expect_error(
-            parser,
-            sql,
-            expression,
-        )