ransacklib 0.1.11__tar.gz → 1.1.0.dev0__tar.gz

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 0.1.11
+Version: 1.1.0.dev0
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
 Project-URL: Repository, https://gitlab.cesnet.cz/713/mentat/ransack
 Project-URL: Documentation, https://ransack-125e0a.gitlab-pages.cesnet.cz/index.html
 Project-URL: Issues, https://gitlab.cesnet.cz/713/mentat/ransack/-/issues
+Project-URL: Changelog, https://gitlab.cesnet.cz/713/mentat/ransack/-/blob/master/CHANGELOG.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
@@ -14,15 +15,17 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: lark<1.3.0,>=1.2.2
+Requires-Dist: lark<1.4.0,>=1.3.0
 Requires-Dist: ipranges<0.2,>=0.1.12
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest<9.0,>=8.4; extra == "dev"
+Requires-Dist: pytest-cov<8.0,>=7.0; extra == "dev"
+Requires-Dist: sphinx<8.2,>=8.1; extra == "dev"
+Requires-Dist: sphinx_rtd_theme<4.0,>=3.0; extra == "dev"
+Requires-Dist: mypy<2.0,>=1.18; extra == "dev"
+Requires-Dist: ruff<0.15,>=0.14; extra == "dev"
+Requires-Dist: build<1.4,>=1.3; extra == "dev"
+Requires-Dist: twine<7.0,>=6.2; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/pyproject.toml

@@ -9,7 +9,7 @@ description = "A modern, extensible language for manipulation with structured da
 license = "MIT"
 readme = "README.rst"
 dependencies = [
-  "lark>=1.2.2,<1.3.0",
+  "lark>=1.3.0,<1.4.0",
   "ipranges>=0.1.12,<0.2",
 ]
 requires-python = ">=3.10"
@@ -25,18 +25,21 @@ classifiers = [
 
 [project.optional-dependencies]
 dev = [
-  "pytest",
-  "pytest-cov",
-  "sphinx",
-  "sphinx_rtd_theme",
-  "mypy",
-  "ruff",
+  "pytest>=8.4,<9.0",
+  "pytest-cov>=7.0,<8.0",
+  "sphinx>=8.1,<8.2", # version 8.2 requires Python>=3.11
+  "sphinx_rtd_theme>=3.0,<4.0",
+  "mypy>=1.18,<2.0",
+  "ruff>=0.14,<0.15",
+  "build>=1.3,<1.4",
+  "twine>=6.2,<7.0",
 ]
 
 [project.urls]
 Repository = "https://gitlab.cesnet.cz/713/mentat/ransack"
 Documentation = "https://ransack-125e0a.gitlab-pages.cesnet.cz/index.html"
 Issues = "https://gitlab.cesnet.cz/713/mentat/ransack/-/issues"
+Changelog = "https://gitlab.cesnet.cz/713/mentat/ransack/-/blob/master/CHANGELOG.md"
 
 [tool.setuptools]
 packages = ["ransack"]
@@ -80,5 +83,4 @@ select = [
 
 ignore = [
     "PLR0913",  # too-many-arguments
-    "UP038",  # deprecated, will be removed
 ]

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/ransack/__init__.py

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

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/ransack/operator.py

@@ -498,3 +498,78 @@ def binary_operation(operator: str, left: Any, right: Any) -> Any:
                 pass
         # Raise an error if the operator is not found in either order
         raise OperatorNotFoundError(operator, (t1, t2), (left, right)) from None
+
+
+def _operator_map_sql(op, l_sql, r_sql, t1, t2) -> tuple[str, Any]:
+    def _get_comp_dict_sql(op: str, tuple_repr_f) -> dict[tuple[Operand, Operand], str]:
+        return {
+            (Number, Number): f"{l_sql} {op} {r_sql}",
+            (Number, list): f"{l_sql} {op} ANY({r_sql})",
+            (Number, tuple): f"{l_sql} {op} {tuple_repr_f}({r_sql})",
+            (datetime, datetime): f"{l_sql} {op} {r_sql}",
+            (datetime, list): f"{l_sql} {op} ANY({r_sql})",
+            (datetime, tuple): f"{r_sql} {op} {tuple_repr_f}({l_sql})",
+            (timedelta, timedelta): f"{l_sql} {op} {r_sql}",
+            (timedelta, list): f"{l_sql} {op} ANY({r_sql})",
+            ("ip", "ip"): f"{l_sql} {op} {r_sql}",
+            ("ip", list): f"{l_sql} {op} ANY({r_sql})",
+            # (list, list): f"{l_sql} && {r_sql}",
+            # (tuple, tuple): f"upper({l_sql}) > lower({r_sql})",
+        }
+
+    d: dict[str, dict] = {
+        "=": {
+            (Number, Number): f"{l_sql} = {r_sql}",
+            (Number, list): f"{l_sql} = ANY({r_sql})",
+            (Number, tuple): f"{r_sql} @> {l_sql}",
+            (datetime, datetime): f"{l_sql} = {r_sql}",
+            (datetime, list): f"{l_sql} = ANY({r_sql})",
+            (datetime, tuple): f"{r_sql} @> {l_sql}",
+            (timedelta, timedelta): f"{l_sql} = {r_sql}",
+            (timedelta, list): f"{l_sql} = ANY({r_sql})",
+            (str, str): f"{l_sql} = {r_sql}",
+            (str, list): f"{l_sql} = ANY({r_sql})",
+            ("ip", "ip"): f"{l_sql} && {r_sql}",
+            ("ip", list): f"{l_sql} && ANY({r_sql})",
+            (list, list): f"{l_sql} && {r_sql}",
+            (tuple, tuple): f"{l_sql} && {r_sql}",
+        },
+        ">": _get_comp_dict_sql(">", "lower")
+        | {(tuple, tuple): f"upper({l_sql}) > lower({r_sql})"},
+        ">=": _get_comp_dict_sql(">=", "lower")
+        | {(tuple, tuple): f"upper({l_sql}) >= lower({r_sql})"},
+        "<": _get_comp_dict_sql("<", "upper")
+        | {(tuple, tuple): f"lower({l_sql}) < upper({r_sql})"},
+        "<=": _get_comp_dict_sql("<=", "upper")
+        | {(tuple, tuple): f"lower({l_sql}) <= upper({r_sql})"},
+        "and": {(bool, bool): f"{l_sql} AND {r_sql}"},
+        "or": {(bool, bool): f"{l_sql} OR {r_sql}"},
+        "contains": {(str, str): f"position({r_sql} in {l_sql})>0"},
+    }
+    if op == "==":
+        return (f"{l_sql} = {r_sql}", bool)
+    if op == "in":
+        return (d["="][(t1, t2)], bool)
+    return (d[op][(t1, t2)], bool)
+
+
+def binary_operation_sql(
+    operator: str, left: str, right: str, l_type: Any, r_type: Any
+) -> tuple[str, Any]:
+    # 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
+    l_type = (
+        "ip" if l_type in (IP4, IP4Net, IP4Range, IP6, IP6Net, IP6Range) else l_type
+    )
+    r_type = (
+        "ip" if r_type in (IP4, IP4Net, IP4Range, IP6, IP6Net, IP6Range) else r_type
+    )
+    try:
+        return _operator_map_sql(operator, left, right, l_type, r_type)
+    except KeyError:
+        try:
+            return _operator_map_sql(operator, right, left, r_type, l_type)
+        except KeyError:
+            pass
+    raise OperatorNotFoundError(operator, (l_type, r_type), (left, right)) from None

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/ransack/parser.py

@@ -112,7 +112,7 @@ class Parser:
         DATE.2: /[0-9]{4}-[0-9]{2}-[0-9]{2}/
         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: /"([^"]+)"|\'([^\']+)\'/
+        STRING: /"([^"]*)"|\'([^\']*)\'/
         VARIABLE: /\.?[_a-zA-Z][-_a-zA-Z0-9]*(?:\.?[_a-zA-Z][-_a-zA-Z0-9]*)*/
         FUNCTION.2: /[_a-zA-Z][_a-zA-Z0-9]*\(/
 

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/ransack/transformer.py

@@ -30,7 +30,7 @@ from lark.visitors import Interpreter
 
 from .exceptions import EvaluationError, RansackError
 from .function import predefined_functions
-from .operator import binary_operation
+from .operator import IP, binary_operation, binary_operation_sql
 
 
 class TokenWrapper:
@@ -807,3 +807,159 @@ class Filter(Interpreter):
             end_column=name.end_column,
             end_pos=name.end_pos,
         )
+
+
+@v_args(inline=True)
+class SQLInterpreter(Interpreter):
+    """
+    A class providing a method for translating the query from 'ransack' language to SQL.
+    """
+
+    def to_sql(self, tree: Tree, data: dict | None = None) -> str:
+        """
+        Translates the given tree to PostgreSQL query using the provided data.
+
+        Parameters:
+            tree: The parse tree to translate to SQL.
+            data: Optional dictionary containing the definition of queried columns.
+
+        Returns:
+            A part of the SQL query - the part after 'SELECT' or 'WHERE'.
+        """
+        self.data = data if data is not None else {}
+
+        result, _ = self.visit(tree)
+
+        self.data = {}
+        return result
+
+    def number(self, token: TokenWrapper) -> tuple[str, type[int | float]]:
+        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
+        return (
+            f"TIMESTAMP WITH TIME ZONE '{token.real_value.isoformat()}'",
+            type(token.real_value),
+        )
+
+    def timedelta_(self, token: TokenWrapper) -> tuple[str, type[timedelta]]:
+        return (f"INTERVAL '{token.real_value!s}'", type(token.real_value))
+
+    def string_(self, token: TokenWrapper) -> tuple[str, type[str]]:
+        return (f"'{token.real_value}'", str)
+
+    def ip(self, token: TokenWrapper) -> tuple[str, type[IP]]:
+        match token.real_value:
+            case IP4() | IP6():
+                cast = "ipaddress"
+            case IP4Range() | IP6Range() | IP4Net() | IP6Net():
+                cast = "iprange"
+        return (f"{cast} '{token.real_value!s}'", type(token.real_value))
+
+    def neg(self, tree: Tree) -> tuple[str, Any]:
+        value, type_ = self.visit(tree)
+        return (f"-{value}", type_)
+
+    @v_args(tree=True)
+    def list(self, data: Tree) -> tuple[str, type[list]]:
+        elements = ", ".join(self.visit(x)[0] for x in data.children if x is not None)
+        return (f"ARRAY[{elements}]", list)
+
+    def range_op(
+        self, l_tree: Tree, r_tree: Tree
+    ) -> tuple[str, type[tuple] | type[IP]]:
+        l_sql, l_type = self.visit(l_tree)
+        r_sql, r_type = self.visit(r_tree)
+
+        if issubclass(l_type, int) and issubclass(r_type, int):
+            range_type = "int4range"
+        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"
+        elif issubclass(l_type, (IP4, IP6)) and issubclass(r_type, (IP4, IP6)):
+            return (
+                f"iprange({l_sql}, {r_sql})",
+                IP4Range if issubclass(l_type, IP4) else IP6Range,
+            )
+        else:
+            raise EvaluationError(
+                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,
+                end_line=r_tree.meta.end_line,
+                end_column=r_tree.meta.end_column,
+                end_pos=r_tree.meta.end_pos,
+            ) from None
+
+        return (
+            (
+                f"CASE WHEN {l_sql} < {r_sql} "
+                f"THEN {range_type}({l_sql}, {r_sql}, '[]') "
+                f"ELSE {range_type}({r_sql}, {l_sql}, '[]') END"
+            ),
+            tuple,
+        )
+
+    def var_from_data(self, var: TokenWrapper) -> tuple[str, Any]:
+        if var.real_value in self.data:
+            column, type_ = self.data[var.real_value]
+            return (f'"{column}"', type_)
+        raise EvaluationError(
+            f"The type of column '{var.real_value}' was not defined",
+            line=var.line,
+            column=var.column,
+            start_pos=var.start_pos,
+            end_line=var.end_line,
+            end_column=var.end_column,
+            end_pos=var.end_pos,
+        )
+
+    def _binary_operation(self, operator, l_tree, r_tree) -> tuple[str, Any]:
+        l_sql, l_type = self.visit(l_tree)
+        r_sql, r_type = self.visit(r_tree)
+
+        return binary_operation_sql(operator, l_sql, r_sql, l_type, r_type)
+
+    def eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("==", l_tree, r_tree)
+
+    def in_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("in", l_tree, r_tree)
+
+    def any_eq(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("=", l_tree, r_tree)
+
+    def gt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation(">", l_tree, r_tree)
+
+    def gte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation(">=", l_tree, r_tree)
+
+    def lt(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("<", l_tree, r_tree)
+
+    def lte(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("<=", l_tree, r_tree)
+
+    def or_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("or", l_tree, r_tree)
+
+    def and_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("and", l_tree, r_tree)
+
+    def not_op(self, tree: Tree) -> tuple[str, type[bool]]:
+        sql, type_ = self.visit(tree)
+        return (f"NOT {sql}", type_)
+
+    def contains_op(self, l_tree: Tree, r_tree: Tree) -> tuple[str, type[bool]]:
+        return self._binary_operation("contains", l_tree, r_tree)
+
+    def exists_op(self, path: Token) -> tuple[str, type[bool]]:
+        return f"{path!s} is not null", bool
+
+    def exists_with_default(self, path: Token, default: Any) -> Any:
+        sql, type_ = self.visit(default)
+        return f"COALESCE({path!s}, {sql})", type_

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

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: ransacklib
-Version: 0.1.11
+Version: 1.1.0.dev0
 Summary: A modern, extensible language for manipulation with structured data
 Author-email: "Rajmund H. Hruška" <rajmund.hruska@cesnet.cz>
 License-Expression: MIT
 Project-URL: Repository, https://gitlab.cesnet.cz/713/mentat/ransack
 Project-URL: Documentation, https://ransack-125e0a.gitlab-pages.cesnet.cz/index.html
 Project-URL: Issues, https://gitlab.cesnet.cz/713/mentat/ransack/-/issues
+Project-URL: Changelog, https://gitlab.cesnet.cz/713/mentat/ransack/-/blob/master/CHANGELOG.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
@@ -14,15 +15,17 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: lark<1.3.0,>=1.2.2
+Requires-Dist: lark<1.4.0,>=1.3.0
 Requires-Dist: ipranges<0.2,>=0.1.12
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pytest<9.0,>=8.4; extra == "dev"
+Requires-Dist: pytest-cov<8.0,>=7.0; extra == "dev"
+Requires-Dist: sphinx<8.2,>=8.1; extra == "dev"
+Requires-Dist: sphinx_rtd_theme<4.0,>=3.0; extra == "dev"
+Requires-Dist: mypy<2.0,>=1.18; extra == "dev"
+Requires-Dist: ruff<0.15,>=0.14; extra == "dev"
+Requires-Dist: build<1.4,>=1.3; extra == "dev"
+Requires-Dist: twine<7.0,>=6.2; extra == "dev"
 Dynamic: license-file
 
 Welcome to ransack

ransacklib-1.1.0.dev0/ransacklib.egg-info/requires.txt

@@ -0,0 +1,12 @@
+lark<1.4.0,>=1.3.0
+ipranges<0.2,>=0.1.12
+
+[dev]
+pytest<9.0,>=8.4
+pytest-cov<8.0,>=7.0
+sphinx<8.2,>=8.1
+sphinx_rtd_theme<4.0,>=3.0
+mypy<2.0,>=1.18
+ruff<0.15,>=0.14
+build<1.4,>=1.3
+twine<7.0,>=6.2

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/tests/test_parser.py

@@ -327,6 +327,16 @@ def test_string_with_special_chars(parser):
     assert special_input in tree.pretty()
 
 
+# Test empty strings
+def test_string_empty(parser):
+    tree = parser.parse_only('""')
+    assert tree is not None
+    assert "string" in tree.pretty()
+    tree = parser.parse_only("''")
+    assert tree is not None
+    assert "string" in tree.pretty()
+
+
 # Test for strings in a larger expression (within arithmetic expression)
 def test_string_in_expression(parser):
     tree = parser.parse_only('"hello" + "world"')

{ransacklib-0.1.11 → ransacklib-1.1.0.dev0}/tests/test_transformer.py

@@ -6,7 +6,13 @@ from lark import Token
 
 from ransack.exceptions import RansackError, ShapeError
 from ransack.parser import Parser
-from ransack.transformer import ExpressionTransformer, Filter, TokenWrapper, get_values
+from ransack.transformer import (
+    ExpressionTransformer,
+    Filter,
+    SQLInterpreter,
+    TokenWrapper,
+    get_values,
+)
 
 
 @pytest.fixture
@@ -500,3 +506,210 @@ class TestFilter:
         exp_tree = expr_transformer.transform(parser.parse_only("my_var == 14"))
         res = filter_.transform(exp_tree)
         assert res
+
+
+@pytest.fixture
+def sql():
+    return SQLInterpreter()
+
+
+class TestSQLInterpreter:
+    def parse_to_sql(self, parser, sql, expression):
+        tree = parser.parse(expression)
+        data = {
+            "a_int": ("a", int),
+            "b_int": ("b", int),
+            "c_int": ("c", int),
+            "d_int": ("d", int),
+            "Description": ("description", str),
+        }
+        return sql.to_sql(tree, data)
+
+    @pytest.mark.parametrize(
+        ("expression", "expected"),
+        [
+            # Test basic types
+            ("5", "5"),
+            ("-12", "-12"),
+            ("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-01T22:14:24.142+02:00",
+                "TIMESTAMP WITH TIME ZONE '2025-01-01T22:14:24.142000+02:00'",
+            ),
+            ("01:23:34", "INTERVAL '1:23:34'"),
+            ("10D23:59:59", "INTERVAL '10 days, 23:59:59'"),
+            ("99:59:59", "INTERVAL '4 days, 3:59:59'"),
+            ("'string'", "'string'"),
+            ("192.168.0.0", "ipaddress '192.168.0.0'"),
+            ("192.168.0.0/16", "iprange '192.168.0.0/16'"),
+            ("192.168.0.10-192.168.0.50", "iprange '192.168.0.10-192.168.0.50'"),
+            ("fd00::1", "ipaddress 'fd00::1'"),
+            ("fd00::/8", "iprange 'fd00::/8'"),
+            ("fd00::1-fd00::10", "iprange 'fd00::1-fd00::10'"),
+            # Test collections
+            ("[1, 2, 3]", "ARRAY[1, 2, 3]"),
+            (
+                "[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[]"),
+            (
+                "100..1",
+                (
+                    "CASE WHEN 100 < 1 "
+                    "THEN int4range(100, 1, '[]') "
+                    "ELSE int4range(1, 100, '[]') END"
+                ),
+            ),
+            (
+                "100.12..1.14",
+                (
+                    "CASE WHEN 100.12 < 1.14 "
+                    "THEN numrange(100.12, 1.14, '[]') "
+                    "ELSE numrange(1.14, 100.12, '[]') END"
+                ),
+            ),
+            (
+                "-10..10",
+                (
+                    "CASE WHEN -10 < 10 "
+                    "THEN int4range(-10, 10, '[]') "
+                    "ELSE int4range(10, -10, '[]') END"
+                ),
+            ),
+            (
+                "2024-01-01..2024-12-31",
+                (
+                    "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 "
+                    "tstzrange(TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00', "
+                    "TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00', '[]') ELSE "
+                    "tstzrange(TIMESTAMP WITH TIME ZONE '2024-12-31T00:00:00+00:00', "
+                    "TIMESTAMP WITH TIME ZONE '2024-01-01T00:00:00+00:00', '[]') END"
+                ),
+            ),
+            (
+                "192.168.0.10..192.168.0.50",
+                "iprange(ipaddress '192.168.0.10', ipaddress '192.168.0.50')",
+            ),
+            ("fd00::1..fd00::10", "iprange(ipaddress 'fd00::1', ipaddress 'fd00::10')"),
+            # Test variable access
+            ("a_int", '"a"'),
+            (
+                "a_int .. b_int",
+                (
+                    'CASE WHEN "a" < "b" '
+                    'THEN int4range("a", "b", \'[]\') '
+                    'ELSE int4range("b", "a", \'[]\') END'
+                ),
+            ),
+            # Test = operator
+            ("1 = 1", "1 = 1"),
+            ("1 = [1, 2, 3]", "1 = ANY(ARRAY[1, 2, 3])"),
+            ("[1, 2, 3] = 1", "1 = ANY(ARRAY[1, 2, 3])"),
+            ("[1, 2] = [3, 4]", "ARRAY[1, 2] && ARRAY[3, 4]"),
+            (
+                "1 = 1..10",
+                (
+                    "CASE WHEN 1 < 10 "
+                    "THEN int4range(1, 10, '[]') "
+                    "ELSE int4range(10, 1, '[]') END @> 1"
+                ),
+            ),
+            (
+                "1..10 = 1",
+                (
+                    "CASE WHEN 1 < 10 "
+                    "THEN int4range(1, 10, '[]') "
+                    "ELSE int4range(10, 1, '[]') END @> 1"
+                ),
+            ),
+            ("0D12:42:24 = 12:42:24", "INTERVAL '12:42:24' = INTERVAL '12:42:24'"),
+            (
+                "a_int..b_int = c_int..d_int",
+                (
+                    'CASE WHEN "a" < "b" '
+                    'THEN int4range("a", "b", \'[]\') '
+                    'ELSE int4range("b", "a", \'[]\') END '
+                    '&& CASE WHEN "c" < "d" '
+                    'THEN int4range("c", "d", \'[]\') '
+                    'ELSE int4range("d", "c", \'[]\') END'
+                ),
+            ),
+            (
+                "10.10.10.10 = 10.10.10.10",
+                "ipaddress '10.10.10.10' && ipaddress '10.10.10.10'",
+            ),
+            (
+                "10.10.10.10 = 10.10.10.0 .. 10.10.10.20",
+                (
+                    "ipaddress '10.10.10.10' && "
+                    "iprange(ipaddress '10.10.10.0', ipaddress '10.10.10.20')"
+                ),
+            ),
+            (
+                "192.168.0.5 = 192.168.0.0-192.168.0.255",
+                "ipaddress '192.168.0.5' && iprange '192.168.0.0-192.168.0.255'",
+            ),
+            (
+                "192.168.0.12 = 192.168.1.0/24",
+                "ipaddress '192.168.0.12' && iprange '192.168.1.0/24'",
+            ),
+            (
+                "10.10.10.10-10.10.10.20 = 10.10.10.15-10.10.10.25",
+                (
+                    "iprange '10.10.10.10-10.10.10.20' && "
+                    "iprange '10.10.10.15-10.10.10.25'"
+                ),
+            ),
+            (
+                "10.10.10.10-10.10.10.20 = 192.168.0.0/16",
+                "iprange '10.10.10.10-10.10.10.20' && iprange '192.168.0.0/16'",
+            ),
+            (
+                "192.168.1.0/24 = 192.168.0.0/16",
+                "iprange '192.168.1.0/24' && iprange '192.168.0.0/16'",
+            ),
+            (
+                "192.168.1.10 = [192.168.0.0/24, 192.168.0.0/16]",
+                (
+                    "ipaddress '192.168.1.10' && "
+                    "ANY(ARRAY[iprange '192.168.0.0/24', iprange '192.168.0.0/16'])"
+                ),
+            ),
+            # Test comparisons
+            ("2 >= 2 and 4 <= 12.89 or 4 == 4", "2 >= 2 AND 4 <= 12.89 OR 4 = 4"),
+            ("3 > 2 or 2 < 1 and 1 > 2", "3 > 2 OR 2 < 1 AND 1 > 2"),
+            ("2 < 3 and 3 > 1 or 1 < 0", "2 < 3 AND 3 > 1 OR 1 < 0"),
+            ("3 > 2 and not 2 < 1", "3 > 2 AND NOT 2 < 1"),
+        ],
+    )
+    def test_to_sql(self, parser, sql, expression, expected):
+        result = self.parse_to_sql(parser, sql, expression)
+        assert result == expected
+
+    def to_sql_and_expect_error(self, parser, sql, expression):
+        """Parse the expression and expect an exception to be raised."""
+        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
+            "not_there",  # Unknown column
+        ],
+    )
+    def test_invalid_cases(self, parser, sql, expression):
+        self.to_sql_and_expect_error(
+            parser,
+            sql,
+            expression,
+        )

ransacklib-0.1.11/ransacklib.egg-info/requires.txt

@@ -1,10 +0,0 @@
-lark<1.3.0,>=1.2.2
-ipranges<0.2,>=0.1.12
-
-[dev]
-pytest
-pytest-cov
-sphinx
-sphinx_rtd_theme
-mypy
-ruff