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

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/tools/rust_api/lbug-src/tools/rust_api/lbug-src/tools/rust_api/lbug-src/scripts/test-simsimd-dispatch.py ADDED Viewed

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

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

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

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

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

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

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

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

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

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