real-ladybug 0.0.1.dev1__cp311-cp311-macosx_11_0_arm64.whl

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/python_api/test/test_torch_geometric_remote_backend.py

@@ -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

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/python_api/test/test_udf.py

@@ -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")

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/python_api/test/test_version.py

@@ -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__

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/python_api/test/test_wal.py

@@ -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()

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/python_api/test/type_aliases.py

@@ -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]

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/scripts/antlr4/hash.py

@@ -0,0 +1,2 @@
+import hashlib, sys
+print(hashlib.md5((''.join(open(sys.argv[1])) + ''.join(open(sys.argv[2]))).encode('utf-8')).hexdigest())

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/scripts/antlr4/keywordhandler.py

@@ -0,0 +1,47 @@
+import sys
+# arg 1 is input Cypher.g4
+inputCypher = open(sys.argv[1], 'r')
+# arg 2 is input keywords.txt
+inputKeywords = [x[:-1] for x in open(sys.argv[2], 'r')]
+# arg 3 is output Cypher.g4
+outputCypher = open(sys.argv[3], 'w')
+# arg 4 is output keywords.h
+outputKeywords = open(sys.argv[4], 'w')
+
+print("Generating keywords for Cypher.g4")
+antlr4String = ''.join(map(
+    lambda x: x + ' : ' + ' '.join([f'( \'{i.upper()}\' | \'{i.lower()}\' )' if i != '_' else f'\'{i}\'' for i in x]) + ' ;\n\n',
+    inputKeywords))
+
+cypherPrefixString = '''
+/*
+* OpenCypher grammar at "https://s3.amazonaws.com/artifacts.opencypher.org/legacy/Cypher.g4"
+*/
+grammar Cypher;
+
+// provide ad-hoc error messages for common syntax errors
+@parser::declarations {
+    virtual void notifyQueryNotConcludeWithReturn(antlr4::Token* startToken) {};
+    virtual void notifyNodePatternWithoutParentheses(std::string nodeName, antlr4::Token* startToken) {};
+    virtual void notifyInvalidNotEqualOperator(antlr4::Token* startToken) {};
+    virtual void notifyEmptyToken(antlr4::Token* startToken) {};
+    virtual void notifyReturnNotAtEnd(antlr4::Token* startToken) {};
+    virtual void notifyNonBinaryComparison(antlr4::Token* startToken) {};
+}
+
+'''
+
+outputCypher.write(cypherPrefixString + antlr4String + '\n' + ''.join(inputCypher))
+print("keywords for Cypher.g4 generated")
+
+print("Generating keywordList for keywords.h")
+asCList = '{"' + '", "'.join(inputKeywords) + '"}'
+
+outputKeywords.write(f'''#ifndef _keywordList
+// clang-format off
+#define _keywordList {asCList}
+#define _keywordListLength {len(inputKeywords)}
+// clang-format on
+#endif
+''')
+print("keywordList generated")

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/scripts/collect-extensions.py

@@ -0,0 +1,68 @@
+import os
+import shutil
+import platform
+
+FILE_DIR = os.path.dirname(os.path.abspath(__file__))
+DST_DIR = os.path.abspath(os.path.join(FILE_DIR, "..", "extension-artifacts"))
+SRC_DIR = os.path.abspath(os.path.join(FILE_DIR, "..", "extension"))
+
+
+def collect_exts():
+    for ext in os.listdir(SRC_DIR):
+        ext_build_path = os.path.abspath(os.path.join(SRC_DIR, ext, "build"))
+        if not os.path.exists(ext_build_path):
+            continue
+        print("Found extension: " + ext)
+        ext_dst_path = os.path.abspath(os.path.join(DST_DIR, ext))
+        os.makedirs(ext_dst_path, exist_ok=True)
+        for f in os.listdir(ext_build_path):
+            if not f.endswith(".lbug_extension"):
+                continue
+            ext_file_path = os.path.abspath(os.path.join(ext_build_path, f))
+            shutil.copy(ext_file_path, ext_dst_path)
+            print(" \tCopied: " + f, "=>", ext_dst_path)
+
+
+def find_duckdb():
+    if platform.system() == "Darwin":
+        candidates = [
+            "/usr/local/lib/libduckdb.dylib",
+            "/opt/homebrew/lib/libduckdb.dylib",
+        ]
+    elif platform.system() == "Linux":
+        candidates = [
+            "/usr/local/lib/libduckdb.so",
+            "/usr/local/lib64/libduckdb.so",
+            "/usr/lib/libduckdb.so",
+            "/usr/lib64/libduckdb.so",
+        ]
+    elif platform.system() == "Windows":
+        candidates = [
+            "C:\\Program Files\\duckdb\\build\\release\\src\\Release\\duckdb.lib"
+        ]
+    for candidate in candidates:
+        if os.path.exists(candidate):
+            return os.path.abspath(candidate)
+    return None
+
+
+def copy_duckdb():
+    duckdb_dst_path = os.path.abspath(os.path.join(DST_DIR, "common"))
+    os.makedirs(duckdb_dst_path, exist_ok=True)
+    duckdb_path = find_duckdb()
+    if duckdb_path is None:
+        print("DuckDB not found, copying is skipped")
+        return
+    shutil.copy(duckdb_path, duckdb_dst_path)
+    print("Copied DuckDB: " + duckdb_path, "=>", duckdb_dst_path)
+
+
+def main():
+    shutil.rmtree(DST_DIR, ignore_errors=True)
+    os.makedirs(DST_DIR, exist_ok=True)
+    collect_exts()
+    copy_duckdb()
+
+
+if __name__ == "__main__":
+    main()

real_ladybug-source/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/scripts/collect-single-file-header.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import graphlib
+import os
+import sys
+import logging
+
+from typing import Optional, Set
+from pathlib import Path
+
+logging.basicConfig(level=logging.WARNING)
+
+BUILD_DIR = Path(sys.argv[1]).resolve()
+SCRIPT_DIR = Path(__file__).parent
+HEADER_BASE_PATH = (SCRIPT_DIR / "../src/include").resolve()
+GENERATED_HEADERS_PATH = BUILD_DIR / "src/include"
+MAIN_HEADER_PATH = HEADER_BASE_PATH / "main"
+START_POINT = MAIN_HEADER_PATH / "lbug.h"
+JSON_HEADER_PATH = (SCRIPT_DIR / "../third_party/nlohmann_json/json_fwd.hpp").resolve()
+ALP_HEADERS_PATH = (SCRIPT_DIR / "../third_party/alp/include").resolve()
+OUTPUT_PATH = "lbug.hpp"
+
+logging.debug("HEADER_BASE_PATH: %s", HEADER_BASE_PATH)
+logging.debug("MAIN_HEADER_PATH: %s", MAIN_HEADER_PATH)
+logging.debug("START_POINT: %s", START_POINT)
+logging.debug("JSON_HEADER_PATH: %s", JSON_HEADER_PATH)
+
+
+def resolve_include(source_header: Path, include_path: str) -> Optional[Path]:
+    if include_path == "json_fwd.hpp":
+        return JSON_HEADER_PATH
+
+    current_directory_include = source_header.parent / include_path
+    if current_directory_include.exists():
+        return current_directory_include
+
+    main_directory_include = HEADER_BASE_PATH / include_path
+    if main_directory_include.exists():
+        return main_directory_include
+
+    generated_header_directory_include = GENERATED_HEADERS_PATH / include_path
+    if generated_header_directory_include.exists():
+        return generated_header_directory_include
+
+    alp_directory_include = ALP_HEADERS_PATH / include_path
+    if alp_directory_include.exists():
+        return alp_directory_include
+
+    return None
+
+
+processed_headers: Set[Path] = set()
+headers: Set[Path] = set()
+with open(SCRIPT_DIR / "headers.txt") as file:
+    for path in file:
+        if not path.strip().startswith("#"):
+            header_path = Path(path.strip().replace("${BUILD_DIR}", str(BUILD_DIR)))
+            if not header_path.is_absolute():
+                header_path = SCRIPT_DIR / ".." / header_path
+            headers.add(header_path.resolve())
+
+
+def build_graph(graph: graphlib.TopologicalSorter, source_file: Path) -> None:
+    assert source_file.is_absolute()
+    global processed_headers
+    if source_file in processed_headers:
+        return
+    processed_headers.add(source_file.resolve())
+
+    with source_file.open("r") as f:
+        for line in f.readlines():
+            if not line.startswith('#include "'):
+                continue
+            header_path = line.split('"')[1]
+            header_real_path = resolve_include(source_file, header_path)
+            if header_real_path is None:
+                logging.error(f"Could not find {header_path} included in {source_file}")
+                sys.exit(1)
+            logging.debug(
+                f"Resolved {header_path} in {source_file} to {header_real_path}"
+            )
+            graph.add(source_file, header_real_path)
+            build_graph(graph, header_real_path)
+
+
+def create_merged_header():
+    graph = graphlib.TopologicalSorter()
+    logging.info("Building dependency graph...")
+    build_graph(graph, START_POINT)
+    if processed_headers != headers:
+        if processed_headers - headers:
+            error_string = os.linesep.join(
+                sorted("\t" + str(header) for header in processed_headers - headers)
+            )
+            raise RuntimeError(
+                "Extra headers were found in the include tree. "
+                "Double-check that these headers should be included in the single file header "
+                f"and if so, add them to headers.txt:{os.linesep}{error_string}"
+            )
+        if headers - processed_headers:
+            error_string = os.linesep.join(
+                sorted(str(header) for header in headers - processed_headers)
+            )
+            raise RuntimeError(
+                "Missing headers from the include tree. "
+                "Double-check that these headers are no longer needed in the single file header "
+                f"and if so, remove them from headers.txt:{os.linesep}{error_string}"
+            )
+    logging.info("Topological sorting...")
+    logging.info("Writing merged header...")
+    with open(OUTPUT_PATH, "w") as f:
+        f.write("#pragma once\n")
+        for header_path in graph.static_order():
+            with header_path.open() as f2:
+                for line in f2.readlines():
+                    if not (
+                        line.startswith("#pragma once") or line.startswith('#include "')
+                    ):
+                        f.write(line)
+
+    logging.info("Done!")
+
+
+if __name__ == "__main__":
+    create_merged_header()