PyPI - real-ladybug - Versions diffs - 0.0.1.dev1__cp311-cp311-macosx_11_0_arm64.whl - Mend

real-ladybug 0.0.1.dev1__cp311-cp311-macosx_11_0_arm64.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 (3088) hide show

@@ -0,0 +1,111 @@
+from __future__ import annotations
+TINY_SNB_KNOWS_GROUND_TRUTH = {
+    0: [2, 3, 5],
+    2: [0, 3, 5],
+    3: [0, 2, 5],
+    5: [0, 2, 3],
+    7: [8, 9],
+}
+TINY_SNB_PERSON_IDS_GROUND_TRUTH = [0, 2, 3, 5, 7, 8, 9, 10]
+# TODO: FIX-ME. Re-enable the tests when StorageDriver is fixed.
+# def test_remote_backend_graph_store(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, gs = db.get_torch_geometric_remote_backend()
+#     edge_idx = gs.get_edge_index(("person", "knows", "person"), layout="coo", is_sorted=False)
+#     assert edge_idx.shape == torch.Size([2, 14])
+#     for i in range(14):
+#         src = edge_idx[0, i].item()
+#         src_id = fs["person", "ID", src].item()
+#         dst = edge_idx[1, i].item()
+#         dst_id = fs["person", "ID", dst].item()
+#         assert src_id in TINY_SNB_KNOWS_GROUND_TRUTH
+#         assert dst_id in TINY_SNB_KNOWS_GROUND_TRUTH[src_id]
+#
+#
+# def test_remote_backend_feature_store_idx(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     id_set = set(TINY_SNB_PERSON_IDS_GROUND_TRUTH)
+#     index_to_id = {}
+#     # Individual index access
+#     for i in range(len(id_set)):
+#         assert fs["person", "ID", i].item() in id_set
+#         id_set.remove(fs["person", "ID", i].item())
+#         index_to_id[i] = fs["person", "ID", i].item()
+#
+#     # Range index access
+#     for i in range(len(index_to_id) - 3):
+#         ids = fs["person", "ID", i : i + 3]
+#         for j in range(3):
+#             assert ids[j].item() == index_to_id[i + j]
+#
+#     # Multiple index access
+#     indicies = random.sample(range(len(index_to_id)), 4)
+#     ids = fs["person", "ID", indicies]
+#     for i in range(4):
+#         idx = indicies[i]
+#         assert ids[i].item() == index_to_id[idx]
+#
+#     # No index access
+#     ids = fs["person", "ID", None]
+#     assert len(ids) == len(index_to_id)
+#     for i in range(len(ids)):
+#         assert ids[i].item() == index_to_id[i]
+#
+#
+# def test_remote_backend_feature_store_types_1d(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     for i in range(3):
+#         assert fs["npyoned", "i64", i].item() - i == 1
+#         assert fs["npyoned", "i32", i].item() - i == 1
+#         assert fs["npyoned", "i16", i].item() - i == 1
+#         assert fs["npyoned", "f64", i].item() - i - 1 < 1e-6
+#         assert fs["npyoned", "f32", i].item() - i - 1 < 1e-6
+#
+#
+# def test_remote_backend_feature_store_types_2d(conn_db_readonly: ConnDB) -> None:
+#     _, db = conn_db_readonly
+#     fs, _ = db.get_torch_geometric_remote_backend()
+#     for i in range(3):
+#         i64 = fs["npytwod", "i64", i]
+#         assert i64.shape == torch.Size([1, 3])
+#         base_number = (i * 3) + 1
+#         for j in range(3):
+#             assert i64[0, j].item() == base_number + j
+#         i32 = fs["npytwod", "i32", i]
+#         assert i32.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert i32[0, j].item() == base_number + j
+#         i16 = fs["npytwod", "i16", i]
+#         assert i16.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert i16[0, j].item() == base_number + j
+#         f64 = fs["npytwod", "f64", i]
+#         assert f64.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert f64[0, j].item() - (base_number + j) - 1 < 1e-6
+#         f32 = fs["npytwod", "f32", i]
+#         assert f32.shape == torch.Size([1, 3])
+#         for j in range(3):
+#             assert f32[0, j].item() - (base_number + j) - 1 < 1e-6
+#
+#
+# def test_remote_backend_20k(conn_db_readwrite: ConnDB) -> None:
+#     _, db = conn_db_readwrite
+#     conn = lb.Connection(db, num_threads=1)
+#     conn.execute("CREATE NODE TABLE npy20k (id INT64,f32 FLOAT[10],PRIMARY KEY(id));")
+#     conn.execute(
+#         f"""
+#         COPY npy20k FROM (
+#           "{LBUG_ROOT}/dataset/npy-20k/id_int64.npy",
+#           "{LBUG_ROOT}/dataset/npy-20k/two_dim_float.npy") BY COLUMN;
+#         """
+#     )
+#     del conn
+#     fs, _ = db.get_torch_geometric_remote_backend(8)
+#     for i in range(20000):
+#         assert fs["npy20k", "id", i].item() == i

@@ -0,0 +1,207 @@
+from __future__ import annotations
+from datetime import date, datetime, timedelta  # noqa: TC003
+import pandas as pd
+import pyarrow as pa
+import pytest
+from real_ladybug import Type
+from type_aliases import ConnDB
+def udf_helper(conn, functionName, params, expectedResult):
+    plist = ", ".join(f"${i + 1}" for i in range(len(params)))
+    queryString = f"RETURN {functionName}({plist})"
+    result = conn.execute(queryString, {str(i + 1): params[i] for i in range(len(params))})
+    assert result.get_next()[0] == expectedResult
+def udf_predicate_test(conn, functionName, params, expectedResult):
+    conn.execute("CREATE node table tbl (id INT64, primary key (id))")
+    for i in params:
+        conn.execute("CREATE (t:tbl {id: $num})", {"num": i})
+    result = conn.execute(f"MATCH (t:tbl) WHERE {functionName}(t.id % 8) RETURN COUNT(*)")
+    assert result.get_next()[0] == expectedResult
+def test_udf(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    def add5int(x: int) -> int:
+        print(x)
+        return x + 5
+    add5IntArgs = ["add5int", add5int]
+    def add5float(x: float) -> float:
+        return x + 5.0
+    add5FloatArgs = ["add5float", add5float]
+    def intToString(x: int) -> str:
+        return str(x)
+    intToStringArgs = ["intToString", intToString]
+    def sumOf7(a, b, c, d, e, f, g) -> int:
+        return a + b + c + d + e + f + g
+    sumOf7Args = ["sumOf7", sumOf7, [Type.INT64] * 7]
+    def dateToDatetime(a: date) -> datetime:
+        return datetime(a.year, a.month, a.day)
+    dateToDatetimeArgs = ["dateToDatetime", dateToDatetime]
+    def datetimeToDate(a: datetime) -> date:
+        return a.date()
+    datetimeToDateArgs = ["datetimeToDate", datetimeToDate, [Type.TIMESTAMP], Type.DATE]
+    def addToDate(a: datetime, b: timedelta) -> datetime:
+        return a + b
+    addToDateArgs = ["addToDate", addToDate, [Type.TIMESTAMP, Type.INTERVAL], Type.TIMESTAMP]
+    def concatThreeLists(a: list[int], b: list[int], c: list[int]) -> list[int]:
+        return a + b + c
+    concatThreeListsArgs = ["concatThreeLists", concatThreeLists]
+    def mergeMaps(a, b):
+        return a | b
+    mergeMapsArgs = ["mergeMaps", mergeMaps, ["MAP(STRING, INT64)"] * 2, "MAP(STRING, INT64)"]
+    def mergeMaps2(a: dict[str, int], b: dict[str, int]) -> dict[str, int]:
+        return a | b
+    mergeMaps2Args = ["mergeMaps2", mergeMaps2]
+    def selectIfSeven(a: int) -> bool:
+        return a == 7
+    selectIfSevenArgs = ["selectIfSeven", selectIfSeven]
+    def distancePrimer(pointA, pointB):
+        return {"x": (pointA["x"] - pointB["x"]) ** 2, "y": (pointA["y"] - pointB["y"]) ** 2}
+    distanceArgs = [
+        "UDFDist",
+        distancePrimer,
+        ["STRUCT(x INT32, y INT32)", "STRUCT(x INT32, y INT32)"],
+        "STRUCT(x INT32, y INT32)",
+    ]
+    conn.create_function(*add5IntArgs)
+    conn.create_function(*add5FloatArgs)
+    conn.create_function(*intToStringArgs)
+    conn.create_function(*sumOf7Args)
+    conn.create_function(*dateToDatetimeArgs)
+    conn.create_function(*datetimeToDateArgs)
+    conn.create_function(*addToDateArgs)
+    conn.create_function(*concatThreeListsArgs)
+    conn.create_function(*mergeMapsArgs)
+    conn.create_function(*mergeMaps2Args)
+    conn.create_function(*selectIfSevenArgs)
+    conn.create_function(*distanceArgs)
+    udf_helper(conn, "add5int", [10], 15)
+    udf_helper(conn, "add5int", [9], 14)
+    udf_helper(conn, "add5int", [1283], 1288)
+    udf_helper(conn, "add5float", [2.2], 7.2)
+    udf_helper(conn, "intToString", [123], "123")
+    udf_helper(conn, "sumOf7", [1, 2, 3, 4, 5, 6, 7], sum(range(8)))
+    udf_helper(conn, "dateToDatetime", [date(2024, 4, 25)], datetime(2024, 4, 25))
+    udf_helper(conn, "datetimeToDate", [datetime(2024, 4, 25, 15, 39, 20)], date(2024, 4, 25))
+    udf_helper(
+        conn,
+        "addToDate",
+        [datetime(2024, 4, 25, 15, 39, 20), datetime(2025, 5, 26) - datetime(2024, 4, 25, 15, 39, 20)],
+        datetime(2025, 5, 26),
+    )
+    udf_helper(conn, "concatThreeLists", [[1, 2, 3], [4, 5, 6], [-1, -2, -3]], [1, 2, 3, 4, 5, 6, -1, -2, -3])
+    udf_helper(
+        conn,
+        "mergeMaps",
+        [{"key": ["a", "b", "c"], "value": [1, 2, 3]}, {"key": ["x", "y", "z"], "value": [100, 200, 300]}],
+        {"a": 1, "b": 2, "c": 3, "x": 100, "y": 200, "z": 300},
+    )
+    udf_helper(
+        conn,
+        "mergeMaps2",
+        [{"key": ["a", "b", "c"], "value": [1, 2, 3]}, {"key": ["x", "y", "z"], "value": [100, 200, 300]}],
+        {"a": 1, "b": 2, "c": 3, "x": 100, "y": 200, "z": 300},
+    )
+    udf_predicate_test(conn, "selectIfSeven", range(65), 8)
+    udf_helper(conn, "UDFDist", [{"x": 1, "y": 10}, {"x": 4, "y": 6}], {"x": 9, "y": 16})
+    df = pd.DataFrame({"col": list(range(5000))})
+    result = conn.execute("LOAD FROM df RETURN add5int(col) as ans").get_as_df()
+    assert list(result["ans"]) == list(map(add5int, range(5000)))
+    df = pd.DataFrame({
+        "col1": pd.Series(
+            [{"a": 1, "b": 2, "c": 3}, {"l": 1, "m": 2, "n": 3}], dtype=pd.ArrowDtype(pa.map_(pa.string(), pa.int64()))
+        ),
+        "col2": pd.Series(
+            [{"x": -1, "y": -2, "z": -3}, {"one": -1, "two": -2, "three": -3}],
+            dtype=pd.ArrowDtype(pa.map_(pa.string(), pa.int64())),
+        ),
+    })
+    # result = conn.execute("LOAD FROM df RETURN mergeMaps(col1, col2) as ans").get_as_arrow()
+    # assert result["ans"].to_pylist() == [
+    #     [("a", 1), ("b", 2), ("c", 3), ("x", -1), ("y", -2), ("z", -3)],
+    #     [("l", 1), ("m", 2), ("n", 3), ("one", -1), ("two", -2), ("three", -3)],
+    # ]
+def test_udf_null(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    def get5(x: int) -> int:
+        return 5
+    conn.create_function("get5", get5)
+    assert conn.execute("RETURN get5(NULL)").get_next() == [None]
+    conn.remove_function("get5")
+    conn.create_function("get5", get5, default_null_handling=False)
+    assert conn.execute("RETURN get5(NULL)").get_next() == [5]
+def test_udf_except(conn_db_readwrite: ConnDB) -> None:
+    class TestException(Exception):
+        pass
+    conn, _ = conn_db_readwrite
+    def throw() -> int:
+        errmsg = "test"
+        raise TestException(errmsg)
+    conn.create_function("testexcept", throw)
+    pytest.raises(RuntimeError, conn.execute, "RETURN testexcept()")
+    conn.remove_function("testexcept")
+    conn.create_function("testexcept", throw, catch_exceptions=True)
+    assert conn.execute("RETURN testexcept()").get_next() == [None]
+def test_udf_remove(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    def myfunction() -> int:
+        return 1
+    conn.create_function("myfunction", myfunction)
+    with pytest.raises(RuntimeError, match=r"Catalog exception: function notmyfunction doesn't exist."):
+        conn.remove_function("notmyfunction")
+    conn.remove_function("myfunction")
+    with pytest.raises(RuntimeError, match=r"Catalog exception: function list_create doesn't exist."):
+        conn.remove_function("list_create")

@@ -0,0 +1,6 @@
+def test_version() -> None:
+    import real_ladybug as lb
+    assert lb.version != ""
+    assert lb.storage_version > 0
+    assert lb.version == lb.__version__

@@ -0,0 +1,80 @@
+import subprocess
+import sys
+import time
+from pathlib import Path
+from textwrap import dedent
+import real_ladybug as lb
+from conftest import get_db_file_path
+def run_query_in_new_process(tmp_path: Path, build_dir: Path, queries: str):
+    db_path = get_db_file_path(tmp_path)
+    code = (
+        dedent(
+            f"""
+        import sys
+        sys.path.append(r"{build_dir!s}")
+        import real_ladybug as lb
+        db = lb.Database(r"{db_path!s}")
+        """
+        )
+        + queries
+    )
+    return subprocess.Popen([sys.executable, "-c", code])
+def run_query_then_kill(tmp_path: Path, build_dir: Path, queries: str):
+    proc = run_query_in_new_process(tmp_path, build_dir, queries)
+    time.sleep(5)
+    proc.kill()
+    proc.wait(5)
+    db_path = get_db_file_path(tmp_path)
+    # Force remove the lock file. Safe since proc.wait() ensures the process has terminated.
+    Path(f"{db_path!s}.lock").unlink(missing_ok=True)
+# Kill the database while it's in the middle of executing a long persistent query
+# When we reload the database we will replay from the WAL (which will be incomplete)
+def test_replay_after_kill(tmp_path: Path, build_dir: Path) -> None:
+    queries = dedent("""
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE tab (id INT64, PRIMARY KEY (id));")
+    conn.execute("UNWIND RANGE(1,100000) AS x UNWIND RANGE(1, 100000) AS y CREATE (:tab {id: x * 100000 + y});")
+    """)
+    run_query_then_kill(tmp_path, build_dir, queries)
+    db_path = get_db_file_path(tmp_path)
+    with lb.Database(db_path) as db, lb.Connection(db) as conn:
+        # previously committed queries should be valid after replaying WAL
+        result = conn.execute("CALL show_tables() RETURN *")
+        assert result.has_next()
+        assert result.get_next()[1] == "tab"
+        assert not result.has_next()
+        result.close()
+def test_replay_with_exception(tmp_path: Path, build_dir: Path) -> None:
+    queries = dedent("""
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE tab (id INT64, PRIMARY KEY (id));")
+    # some of these queries will throw exceptions
+    for i in range(10):
+        try:
+            conn.execute(f"CREATE (:tab {{id: {i // 2}}})")
+            assert i % 2 == 0
+        except:
+            assert i % 2 == 1
+    conn.execute("UNWIND RANGE(1,100000) AS x UNWIND RANGE(1, 100000) AS y CREATE (:tab {id: x * 100000 + y});")
+    """)
+    run_query_then_kill(tmp_path, build_dir, queries)
+    db_path = get_db_file_path(tmp_path)
+    with lb.Database(db_path) as db, lb.Connection(db) as conn:
+        # previously committed queries should be valid after replaying WAL
+        result = conn.execute("match (t:tab) where t.id <= 5 return t.id")
+        assert result.get_num_tuples() == 5
+        for i in range(5):
+            assert result.get_next()[0] == i
+        assert not result.has_next()
+        result.close()

@@ -0,0 +1,10 @@
+import sys
+from real_ladybug import Connection, Database
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+ConnDB: TypeAlias = tuple[Connection, Database]

@@ -0,0 +1,47 @@
+"""Updates the version in Cargo.toml to match the version in the main CMakeLists.txt"""
+import os
+import re
+from pathlib import Path
+LBUG_RS_ROOT = Path(__file__).parent
+LBUG_ROOT = LBUG_RS_ROOT.parent.parent
+def get_lbug_version():
+    cmake_file = LBUG_ROOT / "CMakeLists.txt"
+    with open(cmake_file) as f:
+        for line in f:
+            if line.startswith("project(Lbug VERSION"):
+                version = line.split(" ")[2].strip()
+                # Make version semver-compatible
+                components = version.split(".")
+                if len(components) >= 4:
+                    version = ".".join(components[0:3]) + "-pre." + ".".join(components[3:])
+                return version
+if __name__ == "__main__":
+    version = get_lbug_version()
+    version_changed = False
+    with open(LBUG_RS_ROOT / "Cargo.toml", encoding="utf-8") as file:
+        data = file.readlines()
+        section = None
+        for index, line in enumerate(data):
+            if line.startswith("["):
+                section = line.strip().strip("[]")
+            if line.startswith("version = ") and section == "package":
+                toml_version = re.match('version = "(.*)"', line).group(1)
+                if toml_version != version:
+                    version_changed = True
+                    print(
+                        f"Updating version in Cargo.toml from {toml_version} to {version}"
+                    )
+                    data[index] = re.sub(
+                        'version = ".*"', f'version = "{version}"', line
+                    )
+                    break
+    if version_changed:
+        with open(LBUG_RS_ROOT / "Cargo.toml", "w", encoding="utf-8") as file:
+            file.writelines(data)

@@ -0,0 +1,218 @@
+from __future__ import annotations
+import os
+import shutil
+import subprocess
+import pexpect
+import pytest
+from test_helper import LBUG_EXEC_PATH, LBUG_ROOT, deleteIfExists
+def pytest_addoption(parser) -> None:
+    parser.addoption(
+        "--start-offset",
+        action="store",
+        type=int,
+        help="Skip the first 'n' tests",
+    )
+def pytest_collection_modifyitems(config, items) -> None:
+    start_offset = config.getoption("--start-offset")
+    if not start_offset:
+        # --skiplist not given in cli, therefore move on
+        return
+    skipped = pytest.mark.skip(reason="included in --skiplist")
+    skipped_items = items[:start_offset]
+    for item in skipped_items:
+        item.add_marker(skipped)
+class TestResult:
+    def __init__(self, stdout, stderr, status_code) -> None:
+        self.stdout: str | bytes = stdout
+        self.stderr: str | bytes = stderr
+        self.status_code: int = status_code
+    def check_stdout(self, expected: str | list[str] | bytes) -> None:
+        if isinstance(expected, list):
+            expected = "\n".join(expected)
+        assert self.status_code == 0
+        assert expected in self.stdout
+    def check_not_stdout(self, expected: str | list[str] | bytes) -> None:
+        if isinstance(expected, list):
+            expected = "\n".join(expected)
+        assert self.status_code == 0
+        assert expected not in self.stdout
+    def check_stderr(self, expected: str) -> None:
+        assert expected in self.stderr
+class ShellTest:
+    def __init__(self) -> None:
+        self.shell = LBUG_EXEC_PATH
+        self.arguments = [self.shell]
+        self.statements: list[str] = []
+        self.input = None
+        self.output = None
+        self.environment = {}
+        self.shell_process = None
+    def add_argument(self, *args):
+        self.arguments.extend(args)
+        return self
+    def statement(self, stmt):
+        self.statements.append(stmt)
+        return self
+    def query(self, *stmts):
+        self.statements.extend(stmts)
+        return self
+    def input_file(self, file_path):
+        self.input = file_path
+        return self
+    def output_file(self, file_path):
+        self.output = file_path
+        return self
+    # Test Running methods
+    def get_command(self, cmd: str) -> list[str]:
+        command = self.arguments
+        if self.input:
+            command += [cmd]
+        return command
+    def get_input_data(self, cmd: str):
+        if self.input:
+            with open(self.input, "rb") as f:
+                input_data = f.read()
+        else:
+            input_data = bytearray(cmd, "utf8")
+        return input_data
+    def get_output_pipe(self):
+        output_pipe = subprocess.PIPE
+        if self.output:
+            output_pipe = open(self.output, "w+")
+        return output_pipe
+    def get_statements(self):
+        statements = []
+        for statement in self.statements:
+            statements.append(statement)
+        return "\n".join(statements)
+    def get_output_data(self, res):
+        if self.output:
+            stdout = open(self.output).read()
+        else:
+            stdout = res.stdout.decode("utf8").strip()
+        stderr = res.stderr.decode("utf8").strip()
+        return stdout, stderr
+    def run(self):
+        statements = self.get_statements()
+        command = self.get_command(statements)
+        input_data = self.get_input_data(statements)
+        output_pipe = self.get_output_pipe()
+        my_env = os.environ.copy()
+        for key, val in self.environment.items():
+            my_env[key] = val
+        res = subprocess.run(
+            command,
+            input=input_data,
+            stdout=output_pipe,
+            stderr=subprocess.PIPE,
+            env=my_env,
+            check=False,
+        )
+        stdout, stderr = self.get_output_data(res)
+        return TestResult(stdout, stderr, res.returncode)
+    def start(self) -> None:
+        command = " ".join(self.arguments)
+        my_env = os.environ.copy()
+        for key, val in self.environment.items():
+            my_env[key] = val
+        self.shell_process = pexpect.spawn(command, encoding="utf_8", env=my_env)
+    def send_finished_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.send(stmt)
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+    def send_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.send(stmt)
+    def send_control_statement(self, stmt: str) -> None:
+        if self.shell_process:
+            assert self.shell_process.expect_exact(["lbug", pexpect.EOF]) == 0
+            self.shell_process.sendcontrol(stmt)
+@pytest.fixture()
+def temp_db(tmp_path):
+    shutil.rmtree(tmp_path, ignore_errors=True)
+    return str(tmp_path)
+@pytest.fixture()
+def get_tmp_path(tmp_path):
+    return str(tmp_path)
+@pytest.fixture()
+def history_path():
+    path = os.path.join(LBUG_ROOT, "tools", "shell", "test", "files")
+    deleteIfExists(os.path.join(path, "history.txt"))
+    return path
+@pytest.fixture()
+def csv_path():
+    return os.path.join(LBUG_ROOT, "tools", "shell", "test", "files", "vPerson.csv")
+@pytest.fixture()
+def init_path():
+    return os.path.join(LBUG_ROOT, "tools", "shell", "test", "files", "start.cypher")
+@pytest.fixture
+def test(request):
+    return request.getfixturevalue(request.param)
+@pytest.fixture
+def multiline():
+    test = ShellTest()
+    test.start()
+    return test
+@pytest.fixture
+def singleline():
+    test = ShellTest()
+    test.start()
+    test.send_finished_statement(":singleline\r")
+    assert (
+        test.shell_process.expect_exact(["Single line mode enabled", pexpect.EOF]) == 0
+    )
+    return test