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

real_ladybug-source/scripts/test-simsimd-dispatch.py

@@ -0,0 +1,45 @@
+import gdb
+import subprocess
+
+
+def get_machine_architecture():
+    output = subprocess.check_output(["cat", "/proc/cpuinfo"])
+    flags_str = ""
+    for line in output.decode("utf-8").split("\n"):
+        line = line.strip()
+        if line.startswith("flags"):
+            flags_str = line
+            break
+    assert len(line) > 0
+
+    # Uses the same way as _simsimd_capabilities_x86() in simsimd.h to detect supported features
+    # The only simsimd functions we use in the vector index are cos/l2/l2_sq/dot which only branch for the targets 'skylake', 'haswell', and 'serial' so we only test for those
+    if "avx512f" in flags_str:
+        return "skylake"
+    elif "avx2" in flags_str and "f16c" in flags_str and "fma" in flags_str:
+        return "haswell"
+    else:
+        return "serial"
+
+
+bp = gdb.Breakpoint(f"simsimd_l2_f32_{get_machine_architecture()}")
+
+gdb.execute("run < scripts/simd-dispatch-test.cypher")
+
+try:
+    gdb.execute("continue")
+    # we only care if the breakpoint is hit at all
+    # disable it now to prevent the test from needing to execute 'continue' many times to reach completion
+    bp.enabled = False
+except gdb.error:
+    # the program has terminated
+    pass
+
+# Check if the breakpoint was hit
+if bp.hit_count == 0:
+    print(
+        f"Error: did not hit the expected simsimd function for machine architecture '{get_machine_architecture()}'"
+    )
+    gdb.execute("quit 1")
+
+gdb.execute("quit")

real_ladybug-source/scripts/update-nightly-build-version.py

@@ -0,0 +1,81 @@
+PYPI_URL = "https://pypi.org/pypi/real_ladybug/json"
+CMAKE_KEYWORD = "project(Lbug VERSION "
+CMAKE_SUFFIX = " LANGUAGES CXX C)\n"
+EXTENSION_KEYWORD = 'add_definitions(-DLBUG_EXTENSION_VERSION="'
+EXTENSION_SUFFIX = '")\n'
+EXTENSION_DEV_VERSION = "dev"
+
+import urllib.request
+import urllib.error
+import json
+import os
+import sys
+
+def main():
+    try:
+        from packaging.version import Version
+    except ImportError:
+        from distutils.version import LooseVersion as Version
+    try:
+        with urllib.request.urlopen(PYPI_URL) as url:
+            data = json.loads(url.read().decode())
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            data = {"releases": {}}
+        else:
+            raise
+    releases = data["releases"]
+    versions = list(releases.keys())
+    versions.sort(key=Version)
+    dev_versions = [v for v in versions if "dev" in v]
+    stable_versions = [v for v in versions if not "dev" in v]
+    latest_dev_version = dev_versions[-1] if len(dev_versions) > 0 else None
+    latest_stable_version = stable_versions[-1] if len(stable_versions) > 0 else None
+    print("Latest dev version: %s." % str(latest_dev_version))
+    print("Latest stable version: %s." % str(latest_stable_version))
+    if latest_dev_version is None and latest_stable_version is None:
+        print("No versions found. Defaulting to 0.0.1.dev1.")
+        dev_version = "0.0.1.dev1"
+    elif latest_dev_version is None or Version(latest_dev_version) < Version(latest_stable_version):
+        print("The latest stable version is newer than dev version or no dev version exists. Bumping dev version from stable version.")
+        latest_stable_version_split = latest_stable_version.split(".")
+        latest_stable_version_split[-1] = str(int(latest_stable_version_split[-1]) + 1)
+        latest_stable_version_split.append("dev1")
+        dev_version = ".".join(latest_stable_version_split)
+    else:
+        print("The latest dev version is newer than stable version. Bumping dev version from dev version.")
+        latest_dev_version_split = latest_dev_version.split(".")
+        latest_dev_version_split[-1] = "dev" + str(int(latest_dev_version_split[-1][3:]) + 1)
+        dev_version = ".".join(latest_dev_version_split)
+    print("New Python dev version: %s." % dev_version)
+    cmake_version = dev_version.replace("dev", "")
+    print("New CMake version: %s." % cmake_version)
+    cmake_lists_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "CMakeLists.txt"))
+    print("Updating %s..." % cmake_lists_path)
+    with open(cmake_lists_path, "r") as cmake_lists_file:
+        cmake_lists = cmake_lists_file.readlines()
+    counter = 2
+    for i, line in enumerate(cmake_lists):
+        if CMAKE_KEYWORD in line:
+            cmake_lists[i] = CMAKE_KEYWORD + cmake_version + CMAKE_SUFFIX
+            counter -= 1
+        if EXTENSION_KEYWORD in line:
+            cmake_lists[i] = EXTENSION_KEYWORD + EXTENSION_DEV_VERSION + EXTENSION_SUFFIX
+            counter -= 1
+        if counter == 0:
+            break
+    with open(cmake_lists_path, "w") as cmake_lists_file:
+        cmake_lists_file.writelines(cmake_lists)
+    print("Committing changes...")
+    sys.stdout.flush()
+    os.system("git config user.email ci@lbugdb.com")
+    os.system("git config user.name \"Lbug CI\"")
+    os.system("git add %s" % cmake_lists_path)
+    os.system("git commit -m \"Update CMake version to %s and change extension version to dev.\"" % cmake_version)
+    sys.stdout.flush()
+    sys.stderr.flush()
+    print("All done!")
+    sys.stdout.flush()
+
+if __name__ == "__main__":
+    main()

real_ladybug-source/third_party/brotli/scripts/dictionary/step-01-download-rfc.py

@@ -0,0 +1,16 @@
+# Step 01 - download RFC7932.
+#
+# RFC is the ultimate source for brotli format and constants, including
+# static dictionary.
+
+import urllib2
+
+response = urllib2.urlopen("https://tools.ietf.org/rfc/rfc7932.txt")
+
+text = response.read()
+path = "rfc7932.txt"
+
+with open(path, "w") as rfc:
+  rfc.write(text)
+
+print("Downloaded and saved " + str(len(text)) + " bytes to " + path)

real_ladybug-source/third_party/brotli/scripts/dictionary/step-02-rfc-to-bin.py

@@ -0,0 +1,34 @@
+# Step 02 - parse RFC.
+#
+# Static dictionary is described in "Appendix A" section in a hexadecimal form.
+# This tool locates dictionary data in RFC and converts it to raw binary format.
+
+import re
+
+rfc_path = "rfc7932.txt"
+
+with open(rfc_path, "r") as rfc:
+  lines = rfc.readlines()
+
+re_data_line = re.compile("^      [0-9a-f]{64}$")
+
+appendix_a_found = False
+dictionary = []
+for line in lines:
+  if appendix_a_found:
+    if re_data_line.match(line) is not None:
+      data = line.strip()
+      for i in range(32):
+        dictionary.append(int(data[2 * i:2 * i + 2], 16))
+      if len(dictionary) == 122784:
+        break
+  else:
+    if line.startswith("Appendix A."):
+      appendix_a_found = True
+
+bin_path = "dictionary.bin"
+
+with open(bin_path, "wb") as output:
+  output.write(bytearray(dictionary))
+
+print("Parsed and saved " + str(len(dictionary)) + " bytes to " + bin_path)

real_ladybug-source/third_party/brotli/scripts/dictionary/step-03-validate-bin.py

@@ -0,0 +1,35 @@
+# Step 03 - validate raw dictionary file.
+#
+# CRC32, MD5, SHA1 and SHA256 checksums for raw binary dictionary are checked.
+
+import hashlib
+import zlib
+
+bin_path = "dictionary.bin"
+
+with open(bin_path, "rb") as raw:
+  data = raw.read()
+
+
+def check_digest(name, expected, actual):
+  if expected == actual:
+    print("[OK] " + name)
+  else:
+    print("[ERROR] " + name + " | " + expected + " != " + actual)
+
+
+check_digest(
+    "CRC32",  # This is the only checksum provided in RFC.
+    "0x5136cb04",
+    hex(zlib.crc32(data)))
+
+check_digest("MD5", "96cecd2ee7a666d5aa3627d74735b32a",
+             hashlib.md5(data).hexdigest())
+
+check_digest("SHA1", "72b41051cb61a9281ba3c4414c289da50d9a7640",
+             hashlib.sha1(data).hexdigest())
+
+check_digest(
+    "SHA256",
+    "20e42eb1b511c21806d4d227d07e5dd06877d8ce7b3a817f378f313653f35c70",
+    hashlib.sha256(data).hexdigest())

real_ladybug-source/third_party/brotli/scripts/dictionary/step-04-generate-java-literals.py

@@ -0,0 +1,85 @@
+# Step 04 - generate Java literals.
+#
+# Java byte-code has severe restrictions. There is no such thing as
+# "array literal" - those are implemented as series of data[x] = y;
+# as a consequence N-byte array will use 7N bytes in class, plus N bytes
+# in instantiated variable. Also no literal could be longer than 64KiB.
+#
+# To keep dictionary data compact both in source code and in compiled format
+# we use the following tricks:
+#  * use String as a data container
+#  * store only lowest 7 bits; i.e. all characters fit ASCII table; this allows
+#    efficient conversion to byte array; also ASCII characters use only 1 byte
+#.   of memory (UTF-8 encoding)
+#  * RLE-compress sequence of 8-th bits
+#
+# This script generates literals used in Java code.
+
+try:
+  unichr  # Python 2
+except NameError:
+  unichr = chr  # Python 3
+
+bin_path = "dictionary.bin"
+
+with open(bin_path, "rb") as raw:
+  data = raw.read()
+
+low = []
+hi = []
+is_skip = True
+skip_flip_offset = 36
+cntr = skip_flip_offset
+for b in data:
+  value = ord(b)
+  low.append(chr(value & 0x7F))
+  if is_skip:
+    if value < 0x80:
+      cntr += 1
+    else:
+      is_skip = False
+      hi.append(unichr(cntr))
+      cntr = skip_flip_offset + 1
+  else:
+    if value >= 0x80:
+      cntr += 1
+    else:
+      is_skip = True
+      hi.append(unichr(cntr))
+      cntr = skip_flip_offset + 1
+hi.append(unichr(cntr))
+
+low0 = low[0:len(low) // 2]
+low1 = low[len(low) // 2:len(low)]
+
+
+def escape(chars):
+  result = []
+  for c in chars:
+    if "\r" == c:
+      result.append("\\r")
+    elif "\n" == c:
+      result.append("\\n")
+    elif "\t" == c:
+      result.append("\\t")
+    elif "\"" == c:
+      result.append("\\\"")
+    elif "\\" == c:
+      result.append("\\\\")
+    elif ord(c) < 32 or ord(c) >= 127:
+      result.append("\\u%04X" % ord(c))
+    else:
+      result.append(c)
+  return result
+
+
+source_code = [
+    "  private static final String DATA0 = \"", "".join(escape(low0)), "\";\n",
+    "  private static final String DATA1 = \"", "".join(escape(low1)), "\";\n",
+    "  private static final String SKIP_FLIP = \"", "".join(escape(hi)), "\";\n"
+]
+
+src_path = "DictionaryData.inc.java"
+
+with open(src_path, "w") as source:
+  source.write("".join(source_code))

real_ladybug-source/third_party/pybind11/tools/codespell_ignore_lines_from_errors.py

@@ -0,0 +1,35 @@
+"""Simple script for rebuilding .codespell-ignore-lines
+
+Usage:
+
+cat < /dev/null > .codespell-ignore-lines
+pre-commit run --all-files codespell >& /tmp/codespell_errors.txt
+python3 tools/codespell_ignore_lines_from_errors.py /tmp/codespell_errors.txt > .codespell-ignore-lines
+
+git diff to review changes, then commit, push.
+"""
+
+import sys
+from typing import List
+
+
+def run(args: List[str]) -> None:
+    assert len(args) == 1, "codespell_errors.txt"
+    cache = {}
+    done = set()
+    for line in sorted(open(args[0]).read().splitlines()):
+        i = line.find(" ==> ")
+        if i > 0:
+            flds = line[:i].split(":")
+            if len(flds) >= 2:
+                filename, line_num = flds[:2]
+                if filename not in cache:
+                    cache[filename] = open(filename).read().splitlines()
+                supp = cache[filename][int(line_num) - 1]
+                if supp not in done:
+                    print(supp)
+                    done.add(supp)
+
+
+if __name__ == "__main__":
+    run(args=sys.argv[1:])

real_ladybug-source/third_party/pybind11/tools/libsize.py

@@ -0,0 +1,36 @@
+import os
+import sys
+
+# Internal build script for generating debugging test .so size.
+# Usage:
+#     python libsize.py file.so save.txt -- displays the size of file.so and, if save.txt exists, compares it to the
+#                                           size in it, then overwrites save.txt with the new size for future runs.
+
+if len(sys.argv) != 3:
+    sys.exit("Invalid arguments: usage: python libsize.py file.so save.txt")
+
+lib = sys.argv[1]
+save = sys.argv[2]
+
+if not os.path.exists(lib):
+    sys.exit(f"Error: requested file ({lib}) does not exist")
+
+libsize = os.path.getsize(lib)
+
+print("------", os.path.basename(lib), "file size:", libsize, end="")
+
+if os.path.exists(save):
+    with open(save) as sf:
+        oldsize = int(sf.readline())
+
+    if oldsize > 0:
+        change = libsize - oldsize
+        if change == 0:
+            print(" (no change)")
+        else:
+            print(f" (change of {change:+} bytes = {change / oldsize:+.2%})")
+else:
+    print()
+
+with open(save, "w") as sf:
+    sf.write(str(libsize))

real_ladybug-source/third_party/pybind11/tools/make_changelog.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+
+import re
+
+import ghapi.all
+from rich import print
+from rich.syntax import Syntax
+
+ENTRY = re.compile(
+    r"""
+    Suggested \s changelog \s entry:
+    .*
+    ```rst
+    \s*
+    (.*?)
+    \s*
+    ```
+""",
+    re.DOTALL | re.VERBOSE,
+)
+
+print()
+
+
+api = ghapi.all.GhApi(owner="pybind", repo="pybind11")
+
+issues_pages = ghapi.page.paged(
+    api.issues.list_for_repo, labels="needs changelog", state="closed"
+)
+issues = (issue for page in issues_pages for issue in page)
+missing = []
+
+for issue in issues:
+    changelog = ENTRY.findall(issue.body)
+    if changelog:
+        (msg,) = changelog
+        if not msg.startswith("* "):
+            msg = "* " + msg
+        if not msg.endswith("."):
+            msg += "."
+
+        msg += f"\n  `#{issue.number} <{issue.html_url}>`_"
+
+        print(Syntax(msg, "rst", theme="ansi_light", word_wrap=True))
+        print()
+
+    else:
+        missing.append(issue)
+
+if missing:
+    print()
+    print("[blue]" + "-" * 30)
+    print()
+
+    for issue in missing:
+        print(f"[red bold]Missing:[/red bold][red] {issue.title}")
+        print(f"[red]  {issue.html_url}\n")
+
+    print("[bold]Template:\n")
+    msg = "## Suggested changelog entry:\n\n```rst\n\n```"
+    print(Syntax(msg, "md", theme="ansi_light"))
+
+print()

real_ladybug-source/tools/python_api/build/real_ladybug/__init__.py

@@ -0,0 +1,83 @@
+"""
+# Lbug Python API bindings.
+
+This package provides a Python API for Lbug graph database management system.
+
+To install the package, run:
+```
+python3 -m pip install real_ladybug
+```
+
+Example usage:
+```python
+import real_ladybug as lb
+
+db = lb.Database("./test")
+conn = lb.Connection(db)
+
+# Define the schema
+conn.execute("CREATE NODE TABLE User(name STRING, age INT64, PRIMARY KEY (name))")
+conn.execute("CREATE NODE TABLE City(name STRING, population INT64, PRIMARY KEY (name))")
+conn.execute("CREATE REL TABLE Follows(FROM User TO User, since INT64)")
+conn.execute("CREATE REL TABLE LivesIn(FROM User TO City)")
+
+# Load some data
+conn.execute('COPY User FROM "user.csv"')
+conn.execute('COPY City FROM "city.csv"')
+conn.execute('COPY Follows FROM "follows.csv"')
+conn.execute('COPY LivesIn FROM "lives-in.csv"')
+
+# Query the data
+results = conn.execute("MATCH (u:User) RETURN u.name, u.age;")
+while results.has_next():
+    print(results.get_next())
+```
+
+The dataset used in this example can be found [here](https://github.com/LadybugDB/ladybug/tree/master/dataset/demo-db/csv).
+
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+# Set RTLD_GLOBAL and RTLD_LAZY flags on Linux to fix the issue with loading
+# extensions
+if sys.platform == "linux":
+    original_dlopen_flags = sys.getdlopenflags()
+    sys.setdlopenflags(os.RTLD_GLOBAL | os.RTLD_LAZY)
+
+from .async_connection import AsyncConnection
+from .connection import Connection
+from .database import Database
+from .prepared_statement import PreparedStatement
+from .query_result import QueryResult
+from .types import Type
+
+
+def __getattr__(name: str) -> str | int:
+    if name in ("version", "__version__"):
+        return Database.get_version()
+    elif name == "storage_version":
+        return Database.get_storage_version()
+    else:
+        msg = f"module {__name__!r} has no attribute {name!r}"
+        raise AttributeError(msg)
+
+
+# Restore the original dlopen flags
+if sys.platform == "linux":
+    sys.setdlopenflags(original_dlopen_flags)
+
+__all__ = [
+    "AsyncConnection",
+    "Connection",
+    "Database",
+    "PreparedStatement",
+    "QueryResult",
+    "Type",
+    "__version__",  # noqa: F822
+    "storage_version",  # noqa: F822
+    "version",  # noqa: F822
+]