PyPI - real-ladybug - Versions diffs - 0.0.1.dev1__cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl - Mend

real-ladybug 0.0.1.dev1__cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of real-ladybug might be problematic. Click here for more details.

Files changed (3340) hide show

@@ -0,0 +1,159 @@
+import asyncio
+import time
+import real_ladybug as lb
+import pyarrow as pa
+import pytest
+@pytest.mark.asyncio
+async def test_async_prepare_and_execute(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = $1 RETURN a.age;"
+    result = await async_connection_readonly.execute(query, {"1": 0})
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+    result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_prepare_and_execute_concurrent(async_connection_readonly):
+    num_queries = 100
+    query = "RETURN $1;"
+    results = await asyncio.gather(*[async_connection_readonly.execute(query, {"1": i}) for i in range(num_queries)])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_query(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = 0 RETURN a.age;"
+    result = await async_connection_readonly.execute(query)
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+    result.close()
+    query = "MATCH (a:person) WHERE a.ID = 2 RETURN a.age;"
+    result = await async_connection_readonly.execute(query)
+    assert result.has_next()
+    assert result.get_next() == [30]
+    assert not result.has_next()
+    result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_scan_df(async_connection_readwrite):
+    nodes = pa.Table.from_arrays(
+        [
+            pa.array([1, 2, 3], type=pa.int32()),
+            pa.array(["a", "b", "c"], type=pa.string()),
+            pa.array([True, False, None], type=pa.bool_()),
+        ],
+        names=["id", "A", "B"],
+    )
+    await async_connection_readwrite.execute(
+        "CREATE NODE TABLE pyarrowtab(id INT32, A STRING, B BOOL, PRIMARY KEY(id))"
+    )
+    await async_connection_readwrite.execute("COPY pyarrowtab FROM $tab", {"tab": nodes})
+    result = await async_connection_readwrite.execute(
+        "MATCH (t:pyarrowtab) RETURN t.id AS id, t.A AS A, t.B AS B ORDER BY t.id"
+    )
+    assert result.get_next() == [1, "a", True]
+    assert result.get_next() == [2, "b", False]
+    assert result.get_next() == [3, "c", None]
+    result.close()
+    for i in async_connection_readwrite.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_query_concurrent(async_connection_readonly):
+    num_queries = 100
+    queries = [f"RETURN {i};" for i in range(num_queries)]
+    results = await asyncio.gather(*[async_connection_readonly.execute(query) for query in queries])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_query_multiple_results(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = 0 RETURN a.age; MATCH (a:person) WHERE a.ID = 2 RETURN a.age;"
+    results = await async_connection_readonly.execute(query)
+    assert len(results) == 2
+    result = results[0]
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+    result = results[1]
+    assert result.has_next()
+    assert result.get_next() == [30]
+    assert not result.has_next()
+    for result in results:
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_connection_create_and_close():
+    db = lb.Database(":memory:", buffer_pool_size=2**28)
+    async_connection = lb.AsyncConnection(db)
+    for _ in range(10):
+        res = await async_connection.execute("RETURN 1;")
+        assert res.has_next()
+        assert res.get_next() == [1]
+        assert not res.has_next()
+        res.close()
+    num_queries = 100
+    queries = [f"RETURN {i};" for i in range(num_queries)]
+    results = await asyncio.gather(*[async_connection.execute(query) for query in queries])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    async_connection.close()
+    db.close()
+def test_acquire_connection(async_connection_readonly):
+    conn = async_connection_readonly.acquire_connection()
+    assert conn is not None
+    assert async_connection_readonly.connections_counter[0] == 1
+    result = conn.execute("RETURN 1;")
+    assert result.has_next()
+    assert result.get_next() == [1]
+    assert not result.has_next()
+    result.close()
+    async_connection_readonly.release_connection(conn)
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+@pytest.mark.asyncio
+async def test_async_connection_interrupt(async_connection_readonly) -> None:
+    query = "UNWIND RANGE(1,1000000) AS x UNWIND RANGE(1, 1000000) AS y RETURN COUNT(x + y);"
+    async_connection_readonly.set_query_timeout(100 * 1000)
+    task = asyncio.create_task(async_connection_readonly.execute(query))
+    time.sleep(5)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task

@@ -0,0 +1,145 @@
+from __future__ import annotations
+import re
+import pytest
+from type_aliases import ConnDB
+def test_bytes_param(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+    data_0 = b"\x00\x01\x02\x03\xff"
+    data_1 = b"testing"
+    data_2 = b"A" * 4096  # max size: 4KB, see https://docs.ladybugdb.com/cypher/data-types/#blob
+    data_3 = b""  # empty
+    data_4 = None  # null
+    data_5 = "Hello 🌍"  # str
+    cases = [
+        data_0,
+        data_1,
+        data_2,
+        data_3,
+        data_4,
+        data_5.encode("utf-8"),  # to bytes
+    ]
+    for data in cases:
+        conn.execute("CREATE (t:tab {data: $data})", {"data": data})
+    result = conn.execute("MATCH (t:tab) RETURN t.data ORDER BY t.id")
+    assert result.get_next() == [data_0]
+    assert result.get_next() == [data_1]
+    assert result.get_next() == [data_2]
+    assert result.get_next() == [data_3]
+    assert result.get_next() == [data_4]
+    assert result.get_next()[0].decode("utf-8") == data_5
+    result.close()
+def test_bytes_param_backwards_compatibility(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+    binary = b"backwards_compatibility"
+    string = "".join(f"\\x{b:02x}" for b in binary)  # to \xHH format
+    assert isinstance(string, str)
+    assert re.match(r"^(\\x[0-9a-f]{2})+$", string)
+    conn.execute("CREATE (t:tab {data: BLOB($string)})", {"string": string})
+    result = conn.execute("MATCH (t:tab) RETURN t.data")
+    assert result.get_next() == [binary]
+    result.close()
+def test_bytes_param_where_clause(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id INT64 PRIMARY KEY, data BLOB)")
+    data = b"where_clause"
+    conn.execute("CREATE (t:tab {id: 0, data: $data})", {"data": b"some data"})
+    conn.execute("CREATE (t:tab {id: 1, data: $data})", {"data": data})
+    conn.execute("CREATE (t:tab {id: 2, data: $data})", {"data": b"some other data"})
+    result = conn.execute("MATCH (t:tab) WHERE t.data = $search RETURN t.id", {"search": data})
+    assert result.get_next() == [1]
+    assert not result.has_next()
+    result.close()
+def test_bytes_param_update(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+    initial = b"initial"
+    updated = b"updated"
+    conn.execute("CREATE (t:tab {data: $data})", {"data": initial})
+    conn.execute("MATCH (t:tab) SET t.data = $new_data", {"new_data": updated})
+    result = conn.execute("MATCH (t:tab) RETURN t.data")
+    assert result.get_next() == [updated]
+    result.close()
+def test_bytes_param_mixed_types(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB, name STRING, value DOUBLE)")
+    data = b"data"
+    name = "name"
+    value = 3.14
+    params = {"data": data, "name": name, "value": value}
+    conn.execute("CREATE (t:tab {data: $data, name: $name, value: $value})", params)
+    result = conn.execute("MATCH (t:tab) RETURN t.data, t.name, t.value")
+    assert result.get_next() == [data, name, value]
+    result.close()
+def test_bytes_param_relationship(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE person(name STRING PRIMARY KEY)")
+    conn.execute("CREATE REL TABLE rel(FROM person TO person, data BLOB)")
+    conn.execute("CREATE (p:person {name: 'Alice'})")
+    conn.execute("CREATE (p:person {name: 'Bob'})")
+    data = b"relationship"
+    conn.execute(
+        """
+            MATCH (p1:person {name: 'Alice'}), (p2:person {name: 'Bob'})
+            CREATE (p1)-[r:rel {data: $data}]->(p2)
+        """,
+        {"data": data},
+    )
+    result = conn.execute("MATCH ()-[r:rel]->() RETURN r.data")
+    assert result.get_next() == [data]
+    result.close()
+def test_bytes_param_udf(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    def reverse_bytes(data: bytes) -> bytes:
+        return data[::-1]
+    conn.create_function("reverse_bytes", reverse_bytes, ["BLOB"], "BLOB")
+    data = b"hello"
+    expected = b"olleh"
+    result = conn.execute("RETURN reverse_bytes($data)", {"data": data})
+    assert result.get_next() == [expected]
+    result = conn.execute("RETURN reverse_bytes(NULL)")
+    assert result.get_next() == [None]
+    result.close()

@@ -0,0 +1,49 @@
+from __future__ import annotations
+import threading
+import time
+from typing import TYPE_CHECKING
+import real_ladybug as lb
+import pytest
+from type_aliases import ConnDB
+if TYPE_CHECKING:
+    from pathlib import Path
+def test_connection_close(tmp_path: Path) -> None:
+    db_path = tmp_path / "test_connection_close.lbug"
+    db = lb.Database(database_path=db_path, read_only=False)
+    conn = lb.Connection(db)
+    conn.close()
+    assert conn.is_closed
+    pytest.raises(RuntimeError, conn.execute, "RETURN 1")
+    db.close()
+def test_connection_close_context_manager(tmp_path: Path) -> None:
+    db_path = tmp_path / "test_connection_close_context_manager.lbug"
+    with lb.Database(database_path=db_path, read_only=False) as db:
+        with lb.Connection(db) as conn:
+            pass
+        assert conn.is_closed
+        pytest.raises(RuntimeError, conn.execute, "RETURN 1")
+    assert db.is_closed
+def run_long_query(conn):
+    query = "UNWIND RANGE(1,1000000) AS x UNWIND RANGE(1, 1000000) AS y RETURN COUNT(x + y);"
+    with pytest.raises(RuntimeError) as excinfo:
+        conn.execute(query)
+    assert "Interrupted" in str(excinfo.value)
+def test_connection_interrupt(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    execute_thread = threading.Thread(target=run_long_query, args=(conn,))
+    execute_thread.start()
+    time.sleep(5)
+    conn.interrupt()
+    execute_thread.join(timeout=100)
+    assert not execute_thread.is_alive()

@@ -0,0 +1,234 @@
+from __future__ import annotations
+import subprocess
+import sys
+from pathlib import Path
+from textwrap import dedent
+from typing import TYPE_CHECKING
+import real_ladybug as lb
+import pytest
+from conftest import get_db_file_path
+def open_database_on_subprocess(tmp_path: Path, build_dir: Path) -> None:
+    code = dedent(
+        f"""
+        import sys
+        sys.path.append(r"{build_dir!s}")
+        import real_ladybug as lb
+        db = lb.Database(r"{tmp_path!s}")
+        print(r"{tmp_path!s}")
+    """
+    )
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr)
+def test_database_close(tmp_path: Path, build_dir: Path) -> None:
+    db_path = tmp_path / "test_database_close.lbug"
+    db = lb.Database(database_path=db_path, read_only=False)
+    assert not db.is_closed
+    assert db._database is not None
+    # Open the database on a subprocess. It should raise an exception.
+    with pytest.raises(
+        Exception,
+        match=r"RuntimeError: IO exception: Could not set lock on file",
+    ):
+        open_database_on_subprocess(db_path, build_dir)
+    db.close()
+    assert db.is_closed
+    assert db._database is None
+    # Try to close the database again. It should not raise any exceptions.
+    db.close()
+    assert db.is_closed
+    assert db._database is None
+    # Open the database on a subprocess. It should not raise any exceptions.
+    # TODO: Enable this test on Windows when the read-only mode is implemented.
+    if sys.platform != "win32":
+        open_database_on_subprocess(db_path, build_dir)
+def test_database_context_manager(tmp_path: Path, build_dir: Path) -> None:
+    db_path = tmp_path / "test_database_context_manager.lbug"
+    with lb.Database(database_path=db_path, read_only=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        # Open the database on a subprocess. It should raise an exception.
+        # TODO: Enable this test on Windows when the read-only mode is implemented.
+        if sys.platform != "win32":
+            with pytest.raises(
+                RuntimeError,
+                match=r"RuntimeError: IO exception: Could not set lock on file",
+            ):
+                open_database_on_subprocess(db_path, build_dir)
+    # Open the database on a subprocess. It should not raise any exceptions.
+    # TODO: Enable this test on Windows when the read-only mode is implemented.
+    if sys.platform != "win32":
+        open_database_on_subprocess(db_path, build_dir)
+def test_in_mem_database_memory_db_path() -> None:
+    db = lb.Database(database_path=":memory:")
+    assert not db.is_closed
+    assert db._database is not None
+    # Open the database on a subprocess. It should raise an exception.
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 2
+def test_in_mem_database_empty_db_path() -> None:
+    db = lb.Database()
+    assert not db.is_closed
+    assert db._database is not None
+    # Open the database on a subprocess. It should raise an exception.
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 2
+def test_in_mem_database_no_db_path() -> None:
+    with lb.Database(database_path="") as db:
+        assert not db.is_closed
+        assert db._database is not None
+        # Open the database on a subprocess. It should raise an exception.
+        conn = lb.Connection(db)
+        conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+        conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+        conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+        with conn.execute("MATCH (p:person) RETURN p.*") as result:
+            assert result.get_num_tuples() == 2
+def test_database_auto_checkpoint_config(tmp_path: Path) -> None:
+    with lb.Database(database_path=get_db_file_path(tmp_path), auto_checkpoint=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        conn = lb.Connection(db)
+        with conn.execute("CALL current_setting('auto_checkpoint') RETURN *") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == "False"
+def test_database_checkpoint_threshold_config(tmp_path: Path) -> None:
+    with lb.Database(database_path=get_db_file_path(tmp_path), checkpoint_threshold=1234) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        conn = lb.Connection(db)
+        with conn.execute("CALL current_setting('checkpoint_threshold') RETURN *") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == "1234"
+def test_database_throw_on_wal_replay_failure_config(tmp_path: Path) -> None:
+    database_path = get_db_file_path(tmp_path)
+    wal_file_path = str(database_path) + ".wal"
+    with Path.open(wal_file_path, "w") as wal_file:
+        wal_file.write("a" * 28)
+    with lb.Database(database_path=database_path, throw_on_wal_replay_failure=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        conn = lb.Connection(db)
+        with conn.execute("RETURN 1") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == 1
+def test_database_enable_checksums_config(tmp_path: Path) -> None:
+    database_path = get_db_file_path(tmp_path)
+    # first construct database file with enable_checksums=True
+    with lb.Database(database_path=database_path) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        conn = lb.Connection(db)
+        # do some updates to leave a WAL
+        conn.execute("call auto_checkpoint=false")
+        conn.execute("call force_checkpoint_on_close=false")
+        conn.execute("create node table test(id int64 primary key)")
+    # running again with enable_checksums=False should give an error
+    with pytest.raises(RuntimeError) as check:
+        db = lb.Database(database_path=database_path, enable_checksums=False)
+def test_database_close_order() -> None:
+    in_mem_db = lb.Database(database_path=":memory:", buffer_pool_size=1024 * 1024 * 10)
+    assert not in_mem_db.is_closed
+    assert in_mem_db._database is not None
+    in_mem_conn = lb.Connection(in_mem_db)
+    assert not in_mem_conn.is_closed
+    assert in_mem_conn._connection is not None
+    query_result = in_mem_conn.execute("RETURN 1+1")
+    assert not query_result.is_closed
+    assert query_result._query_result is not None
+    assert query_result.get_next()[0] == 2
+    # Close the database first, it should not cause crashes or exceptions
+    in_mem_db.close()
+    # The query result and connection will be unusable after the database is closed.
+    # But calling methods on them should raise exceptions instead of crashing.
+    with pytest.raises(Exception, match="Database is closed"):
+        in_mem_conn.execute("RETURN 1+1")
+    with pytest.raises(Exception, match="the parent database is closed"):
+        query_result.get_next()
+    # Close the connection and query result, they should not raise any exceptions.
+    in_mem_conn.close()
+    query_result.close()
+def test_database_close_order_with_multiple_statements() -> None:
+    in_mem_db = lb.Database(database_path=":memory:", buffer_pool_size=1024 * 1024 * 10)
+    assert not in_mem_db.is_closed
+    assert in_mem_db._database is not None
+    in_mem_conn = lb.Connection(in_mem_db)
+    assert not in_mem_conn.is_closed
+    assert in_mem_conn._connection is not None
+    query_results = in_mem_conn.execute("RETURN 1+1; RETURN 2+2; RETURN 3+3;")
+    for i, qr in enumerate(query_results):
+        assert not qr.is_closed
+        assert qr._query_result is not None
+        assert qr.get_next()[0] == (i + 1) * 2
+    # Close the database first, it should not cause crashes or exceptions
+    in_mem_db.close()
+    # The query result and connection will be unusable after the database is closed.
+    # But calling methods on them should raise exceptions instead of crashing.
+    with pytest.raises(Exception, match="Database is closed"):
+        in_mem_conn.execute("RETURN 1+1")
+    with pytest.raises(Exception, match="the parent database is closed"):
+        query_results[0].get_next()
+    # Close the connection and query result, they should not raise any exceptions.
+    in_mem_conn.close()
+    for qr in query_results:
+        qr.close()