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

real_ladybug-0.0.1.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

real_ladybug-0.0.1.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2025 Kùzu Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

real_ladybug-0.0.1.dev1.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+build
+real_ladybug
+real_ladybug-source

real_ladybug-0.0.1.dev1.dist-info/zip-safe

@@ -0,0 +1 @@
+

real_ladybug-source/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/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/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/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()

real_ladybug-source/scripts/export-dbs.py

@@ -0,0 +1,101 @@
+import argparse
+import os
+import sys
+import subprocess
+
+
+# Parse schema.cypher and copy.cypher files.
+def create_cypher_queries(file_path):
+    commands = []
+    try:
+        with open(file_path, "r") as f:
+            for line in f:
+                stripped = line.strip()
+                if not stripped:
+                    continue
+                if not stripped.endswith(";"):
+                    stripped += ";"
+                commands.append(stripped)
+    except Exception:
+        pass
+    return commands
+
+
+# Find all datasets that have a schema.cypher and copy.cypher file.
+def find_valid_dataset_dirs(dataset_root):
+    valid_dirs = []
+
+    for root, dirs, files in os.walk(dataset_root):
+        # This script creates a tmp directory with the exported dbs, we should
+        # skip it in our search.
+        if "tmp" in root.split(os.sep):
+            continue
+        file_set = set(files)
+
+        if "schema.cypher" in file_set:
+            valid_dirs.append(root)
+
+    return valid_dirs
+
+
+# Example scripts/export-dbs.py build/debug/tools/shell/lbug dataset.
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export DBs with LBUG shell and dataset paths"
+    )
+
+    parser.add_argument(
+        "--executable", required=True, help="Path to the LBUG shell executable"
+    )
+    parser.add_argument(
+        "--dataset-dir", required=True, help="Path to the dataset directory"
+    )
+    parser.add_argument(
+        "--output-dir", required=True, help="Path to export the datasets"
+    )
+    args = parser.parse_args()
+
+    arg_executable_path = os.path.abspath(args.executable)
+    arg_dataset_path = os.path.abspath(args.dataset_dir)
+    output_dir = os.path.abspath(args.output_dir)
+
+    if not os.path.isfile(arg_executable_path):
+        raise Exception(f"Error: Executable not found at {arg_executable_path}")
+    if not os.path.exists(arg_dataset_path):
+        raise Exception(f"Error: Dataset path not found at {arg_dataset_path}")
+
+    valid_datasets = find_valid_dataset_dirs(arg_dataset_path)
+    # This is done to construct a full path to replace the relative paths found
+    # in copy.cypher files.
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    root_dir = os.path.abspath(os.path.join(script_dir, ".."))
+    for dataset_path in valid_datasets:
+        schema_commands = create_cypher_queries(
+            os.path.join(dataset_path, "schema.cypher")
+        )
+        copy_commands = create_cypher_queries(os.path.join(dataset_path, "copy.cypher"))
+        combined_commands = schema_commands + copy_commands
+        dataset_name = os.path.relpath(dataset_path, arg_dataset_path)
+        export_path = os.path.join(output_dir, dataset_name)
+        export_command = (
+            f"EXPORT DATABASE '{export_path}' (format=\"csv\", header=true);"
+        )
+        combined_commands.append(export_command)
+        combined_commands.insert(0, "CALL threads=1;")
+        print(f"Exporting {dataset_path} to {export_path}")
+        joined_commands = "\n".join(cmd.strip() for cmd in combined_commands)
+
+        subprocess.run(
+            arg_executable_path,
+            input=joined_commands,
+            text=True,
+            cwd=root_dir,
+            check=True,
+            shell=True,
+        )
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())