real-ladybug 0.0.1.dev1__cp310-cp310-win_amd64.whl

real_ladybug/torch_geometric_graph_store.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import multiprocessing
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import torch
+from torch_geometric.data.graph_store import EdgeAttr, EdgeLayout, GraphStore
+
+from .connection import Connection
+
+if TYPE_CHECKING:
+    import sys
+
+    from torch_geometric.typing import EdgeTensorType
+
+    from .database import Database
+
+    if sys.version_info >= (3, 10):
+        from typing import TypeAlias
+    else:
+        from typing_extensions import TypeAlias
+
+StoreKeyType: TypeAlias = tuple[tuple[str], Any, bool]
+
+REL_BATCH_SIZE = 1000000
+
+
+@dataclass
+class Rel:  # noqa: D101
+    edge_type: tuple[str, ...]
+    layout: str
+    is_sorted: bool
+    size: tuple[int, ...]
+    materialized: bool = False
+    edge_index: EdgeTensorType | None = None
+
+
+class LbugGraphStore(GraphStore):  # type: ignore[misc]
+    """Graph store compatible with `torch_geometric`."""
+
+    def __init__(self, db: Database, num_threads: int | None = None):
+        super().__init__()
+        self.db = db
+        self.connection: Connection | None = None
+        self.store: dict[StoreKeyType, Rel] = {}
+        if num_threads is None:
+            num_threads = multiprocessing.cpu_count()
+        self.num_threads = num_threads
+        self.__populate_edge_attrs()
+
+    @staticmethod
+    def key(attr: EdgeAttr) -> tuple[tuple[str], Any, bool]:  # noqa: D102
+        return attr.edge_type, attr.layout.value, attr.is_sorted
+
+    def _put_edge_index(self, edge_index: EdgeTensorType, edge_attr: EdgeAttr) -> None:
+        key = self.key(edge_attr)
+        if key in self.store:
+            self.store[key].edge_index = edge_index
+            self.store[key].materialized = True
+            self.store[key].size = edge_attr.size
+        else:
+            self.store[key] = Rel(key[0], key[1], key[2], edge_attr.size, True, edge_index)
+
+    def _get_edge_index(self, edge_attr: EdgeAttr) -> EdgeTensorType | None:
+        if edge_attr.layout.value == EdgeLayout.COO.value:  # noqa: SIM102
+            # We always return a sorted COO edge index, if the request is
+            # for an unsorted COO edge index, we change the is_sorted flag
+            # to True and return the sorted COO edge index.
+            if edge_attr.is_sorted is False:
+                edge_attr.is_sorted = True
+
+        key = self.key(edge_attr)
+        if key in self.store:
+            rel = self.store[self.key(edge_attr)]
+            if not rel.materialized and rel.layout != EdgeLayout.COO.value:
+                msg = "Only COO layout is supported"
+                raise ValueError(msg)
+
+            if rel.layout == EdgeLayout.COO.value:
+                self.__get_edge_coo_from_database(self.key(edge_attr))
+            return rel.edge_index
+        else:
+            return None
+
+    def _remove_edge_index(self, edge_attr: EdgeAttr) -> None:
+        key = self.key(edge_attr)
+        if key in self.store:
+            del self.store[key]
+
+    def get_all_edge_attrs(self) -> list[EdgeAttr]:
+        """Return all EdgeAttr from the store values."""
+        return [EdgeAttr(rel.edge_type, rel.layout, rel.is_sorted, rel.size) for rel in self.store.values()]
+
+    def __get_edge_coo_from_database(self, key: StoreKeyType) -> None:
+        if not self.connection:
+            self.connection = Connection(self.db, self.num_threads)
+
+        rel = self.store[key]
+        if rel.layout != EdgeLayout.COO.value:
+            msg = "Only COO layout is supported"
+            raise ValueError(msg)
+        if rel.materialized:
+            return
+
+        edge_type = rel.edge_type
+        num_edges = self.connection._connection.get_num_rels(edge_type[1])
+        result = np.empty(2 * num_edges, dtype=np.int64)
+        self.connection._connection.get_all_edges_for_torch_geometric(
+            result, edge_type[0], edge_type[1], edge_type[2], REL_BATCH_SIZE
+        )
+        edge_list = torch.from_numpy(result)
+        edge_list = edge_list.reshape((2, edge_list.shape[0] // 2))
+        rel.edge_index = edge_list
+        rel.materialized = True
+
+    def __populate_edge_attrs(self) -> None:
+        if not self.connection:
+            self.connection = Connection(self.db, self.num_threads)
+        rel_tables = self.connection._get_rel_table_names()
+        for rel_table in rel_tables:
+            edge_type = (rel_table["src"], rel_table["name"], rel_table["dst"])
+            size = self.__get_size(edge_type)
+            rel = Rel(edge_type, EdgeLayout.COO.value, True, size, False, None)
+            self.store[self.key(EdgeAttr(edge_type, EdgeLayout.COO, True))] = rel
+
+    def __get_size(self, edge_type: tuple[str, ...]) -> tuple[int, int]:
+        num_nodes = self.connection._connection.get_num_nodes  # type: ignore[union-attr]
+        src_count, dst_count = num_nodes(edge_type[0]), num_nodes(edge_type[-1])
+        return (src_count, dst_count)

real_ladybug/torch_geometric_result_converter.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from .types import Type
+
+if TYPE_CHECKING:
+    import torch_geometric.data as geo
+
+    from .query_result import QueryResult
+
+from .constants import ID, LABEL, SRC, DST
+
+
+class TorchGeometricResultConverter:
+    """Convert graph results to `torch_geometric`."""
+
+    def __init__(self, query_result: QueryResult):
+        self.query_result = query_result
+        self.nodes_dict: dict[str, Any] = {}
+        self.edges_dict: dict[str, Any] = {}
+        self.edges_properties: dict[str | tuple[str, str], dict[str, Any]] = {}
+        self.rels: dict[tuple[Any, ...], dict[str, Any]] = {}
+        self.nodes_property_names_dict: dict[str, Any] = {}
+        self.table_to_label_dict: dict[int, str] = {}
+        self.internal_id_to_pos_dict: dict[tuple[int, int], int | None] = {}
+        self.pos_to_primary_key_dict: dict[str, Any] = {}
+        self.warning_messages: set[str] = set()
+        self.unconverted_properties: dict[str, Any] = {}
+        self.properties_to_extract = self.query_result._get_properties_to_extract()
+
+    def __get_node_property_names(self, table_name: str) -> dict[str, Any]:
+        if table_name in self.nodes_property_names_dict:
+            return self.nodes_property_names_dict[table_name]
+        results = self.query_result.connection._get_node_property_names(table_name)
+        self.nodes_property_names_dict[table_name] = results
+        return results
+
+    def __populate_nodes_dict_and_deduplicte_edges(self) -> None:
+        self.query_result.reset_iterator()
+        while self.query_result.has_next():
+            row = self.query_result.get_next()
+            for i in self.properties_to_extract:
+                column_type, _ = self.properties_to_extract[i]
+                if column_type == Type.NODE.value:
+                    node = row[i]
+                    label = node[LABEL]
+                    nid = node[ID]
+                    self.table_to_label_dict[nid["table"]] = label
+
+                    if (nid["table"], nid["offset"]) in self.internal_id_to_pos_dict:
+                        continue
+
+                    node_property_names = self.__get_node_property_names(label)
+
+                    pos, primary_key = self.__extract_properties_from_node(node, label, node_property_names)
+
+                    self.internal_id_to_pos_dict[nid["table"], nid["offset"]] = pos
+                    if label not in self.pos_to_primary_key_dict:
+                        self.pos_to_primary_key_dict[label] = {}
+                    self.pos_to_primary_key_dict[label][pos] = primary_key
+
+                elif column_type == Type.REL.value:
+                    src = row[i][SRC]
+                    dst = row[i][DST]
+                    self.rels[src["table"], src["offset"], dst["table"], dst["offset"]] = row[i]
+
+    def __extract_properties_from_node(
+        self,
+        node: dict[str, Any],
+        label: str,
+        node_property_names: dict[str, Any],
+    ) -> tuple[int | None, Any]:
+        pos = None
+        import torch
+
+        for prop_name in node_property_names:
+            # Read primary key
+            if node_property_names[prop_name]["is_primary_key"]:
+                primary_key = node[prop_name]
+
+            # If property is already marked as unconverted, then add it directly without further checks
+            if label in self.unconverted_properties and prop_name in self.unconverted_properties[label]:
+                pos = self.__add_unconverted_property(node, label, prop_name)
+                continue
+
+            # Mark properties that are not supported by torch_geometric as unconverted
+            if node_property_names[prop_name]["type"] not in [Type.INT64.value, Type.DOUBLE.value, Type.BOOL.value]:
+                self.warning_messages.add(
+                    "Property {}.{} of type {} is not supported by torch_geometric. The property is marked as unconverted.".format(
+                        label, prop_name, node_property_names[prop_name]["type"]
+                    )
+                )
+                self.__mark_property_unconverted(label, prop_name)
+                pos = self.__add_unconverted_property(node, label, prop_name)
+                continue
+            if node[prop_name] is None:
+                self.warning_messages.add(
+                    f"Property {label}.{prop_name} has a null value. torch_geometric does not support null values. The property is marked as unconverted."
+                )
+                self.__mark_property_unconverted(label, prop_name)
+                pos = self.__add_unconverted_property(node, label, prop_name)
+                continue
+
+            if node_property_names[prop_name]["dimension"] == 0:
+                curr_value = node[prop_name]
+            else:
+                try:
+                    if node_property_names[prop_name]["type"] == Type.INT64.value:
+                        curr_value = torch.LongTensor(node[prop_name])
+                    elif node_property_names[prop_name]["type"] == Type.DOUBLE.value:
+                        curr_value = torch.FloatTensor(node[prop_name])
+                    elif node_property_names[prop_name]["type"] == Type.BOOL.value:
+                        curr_value = torch.BoolTensor(node[prop_name])
+                except ValueError:
+                    self.warning_messages.add(
+                        f"Property {label}.{prop_name} cannot be converted to Tensor (likely due to nested list of variable length). The property is marked as unconverted."
+                    )
+                    self.__mark_property_unconverted(label, prop_name)
+                    pos = self.__add_unconverted_property(node, label, prop_name)
+                    continue
+
+                # Check if the shape of the property is consistent
+                if label in self.nodes_dict and prop_name in self.nodes_dict[label]:  # noqa: SIM102
+                    # If the shape is inconsistent, then mark the property as unconverted
+                    if curr_value.shape != self.nodes_dict[label][prop_name][0].shape:
+                        self.warning_messages.add(
+                            f"Property {label}.{prop_name} has an inconsistent shape. The property is marked as unconverted."
+                        )
+                        self.__mark_property_unconverted(label, prop_name)
+                        pos = self.__add_unconverted_property(node, label, prop_name)
+                        continue
+
+            # Create the dictionary for the label if it does not exist
+            if label not in self.nodes_dict:
+                self.nodes_dict[label] = {}
+            if prop_name not in self.nodes_dict[label]:
+                self.nodes_dict[label][prop_name] = []
+
+            # Add the property to the dictionary
+            self.nodes_dict[label][prop_name].append(curr_value)
+
+            # The pos will be overwritten for each property, but
+            # it should be the same for all properties
+            pos = len(self.nodes_dict[label][prop_name]) - 1
+        return pos, primary_key
+
+    def __add_unconverted_property(self, node: dict[str, Any], label: str, prop_name: str) -> int:
+        self.unconverted_properties[label][prop_name].append(node[prop_name])
+        return len(self.unconverted_properties[label][prop_name]) - 1
+
+    def __mark_property_unconverted(self, label: str, prop_name: str) -> None:
+        import torch
+
+        if label not in self.unconverted_properties:
+            self.unconverted_properties[label] = {}
+        if prop_name not in self.unconverted_properties[label]:
+            if label in self.nodes_dict and prop_name in self.nodes_dict[label]:
+                self.unconverted_properties[label][prop_name] = self.nodes_dict[label][prop_name]
+                del self.nodes_dict[label][prop_name]
+                if len(self.nodes_dict[label]) == 0:
+                    del self.nodes_dict[label]
+                for i in range(len(self.unconverted_properties[label][prop_name])):
+                    # If the property is a tensor, convert it back to list (consistent with the original type)
+                    if torch.is_tensor(self.unconverted_properties[label][prop_name][i]):  # type: ignore[no-untyped-call]
+                        self.unconverted_properties[label][prop_name][i] = self.unconverted_properties[label][
+                            prop_name
+                        ][i].tolist()
+            else:
+                self.unconverted_properties[label][prop_name] = []
+
+    def __populate_edges_dict(self) -> None:
+        # Post-process edges, map internal ids to positions
+        for r in self.rels:
+            src_pos = self.internal_id_to_pos_dict[r[0], r[1]]
+            dst_pos = self.internal_id_to_pos_dict[r[2], r[3]]
+            src_label = self.table_to_label_dict[r[0]]
+            dst_label = self.table_to_label_dict[r[2]]
+            if src_label not in self.edges_dict:
+                self.edges_dict[src_label] = {}
+            if dst_label not in self.edges_dict[src_label]:
+                self.edges_dict[src_label][dst_label] = []
+            self.edges_dict[src_label][dst_label].append((src_pos, dst_pos))
+            curr_edge_properties = self.rels[r]
+            if (src_label, dst_label) not in self.edges_properties:
+                self.edges_properties[src_label, dst_label] = {}
+            for prop_name in curr_edge_properties:
+                if prop_name in [SRC, DST, ID]:
+                    continue
+                if prop_name not in self.edges_properties[src_label, dst_label]:
+                    self.edges_properties[src_label, dst_label][prop_name] = []
+                self.edges_properties[src_label, dst_label][prop_name].append(curr_edge_properties[prop_name])
+
+    def __print_warnings(self) -> None:
+        for message in self.warning_messages:
+            warnings.warn(message, stacklevel=2)
+
+    def __convert_to_torch_geometric(
+        self,
+    ) -> tuple[
+        geo.Data | geo.HeteroData,
+        dict[str, Any],
+        dict[str, Any],
+        dict[str | tuple[str, str], dict[str, Any]],
+    ]:
+        import torch
+        import torch_geometric
+
+        if len(self.nodes_dict) == 0:
+            self.warning_messages.add("No nodes found or all node properties are not converted.")
+
+        # If there is only one node type, then convert to torch_geometric.data.Data
+        # Otherwise, convert to torch_geometric.data.HeteroData
+        if len(self.nodes_dict) == 1:
+            data = torch_geometric.data.Data()
+            is_hetero = False
+        else:
+            data = torch_geometric.data.HeteroData()
+            is_hetero = True
+
+        # Convert nodes to tensors
+        converted: torch.Tensor
+        for label in self.nodes_dict:
+            for prop_name in self.nodes_dict[label]:
+                prop_type = self.nodes_property_names_dict[label][prop_name]["type"]
+                prop_dimension = self.nodes_property_names_dict[label][prop_name]["dimension"]
+                if prop_dimension == 0:
+                    if prop_type == Type.INT64.value:
+                        converted = torch.LongTensor(self.nodes_dict[label][prop_name])
+                    elif prop_type == Type.BOOL.value:
+                        converted = torch.BoolTensor(self.nodes_dict[label][prop_name])
+                    elif prop_type == Type.DOUBLE.value:
+                        converted = torch.FloatTensor(self.nodes_dict[label][prop_name])
+                else:
+                    converted = torch.stack(self.nodes_dict[label][prop_name], dim=0)
+                if is_hetero:
+                    data[label][prop_name] = converted
+                else:
+                    data[prop_name] = converted
+
+        # Convert edges to tensors
+        for src_label in self.edges_dict:
+            for dst_label in self.edges_dict[src_label]:
+                edge_idx = torch.tensor(self.edges_dict[src_label][dst_label], dtype=torch.long).t().contiguous()
+                if is_hetero:
+                    data[src_label, dst_label].edge_index = edge_idx
+                else:
+                    data.edge_index = edge_idx
+
+        pos_to_primary_key_dict: dict[str, Any] = (
+            self.pos_to_primary_key_dict[label] if not is_hetero else self.pos_to_primary_key_dict
+        )
+
+        if is_hetero:
+            unconverted_properties = self.unconverted_properties
+            edge_properties = self.edges_properties
+        else:
+            if len(self.unconverted_properties) == 0:
+                unconverted_properties = {}
+            else:
+                unconverted_properties = self.unconverted_properties[next(iter(self.unconverted_properties))]
+            if len(self.edges_properties) == 0:
+                edge_properties = {}
+            else:
+                edge_properties = self.edges_properties[next(iter(self.edges_properties))]  # type: ignore[assignment]
+        return data, pos_to_primary_key_dict, unconverted_properties, edge_properties
+
+    def get_as_torch_geometric(
+        self,
+    ) -> tuple[
+        geo.Data | geo.HeteroData,
+        dict[str, Any],
+        dict[str, Any],
+        dict[str | tuple[str, str], dict[str, Any]],
+    ]:
+        """Convert graph data to `torch_geometric`."""
+        self.__populate_nodes_dict_and_deduplicte_edges()
+        self.__populate_edges_dict()
+        result = self.__convert_to_torch_geometric()
+        self.__print_warnings()
+        return result

real_ladybug/types.py

@@ -0,0 +1,39 @@
+from enum import Enum
+
+
+class Type(Enum):
+    """The type of a value in the database."""
+
+    ANY = "ANY"
+    NODE = "NODE"
+    REL = "REL"
+    RECURSIVE_REL = "RECURSIVE_REL"
+    SERIAL = "SERIAL"
+    BOOL = "BOOL"
+    INT64 = "INT64"
+    INT32 = "INT32"
+    INT16 = "INT16"
+    INT8 = "INT8"
+    UINT64 = "UINT64"
+    UINT32 = "UINT32"
+    UINT16 = "UINT16"
+    UINT8 = "UINT8"
+    INT128 = "INT128"
+    DOUBLE = "DOUBLE"
+    FLOAT = "FLOAT"
+    DATE = "DATE"
+    TIMESTAMP = "TIMESTAMP"
+    TIMSTAMP_TZ = "TIMESTAMP_TZ"
+    TIMESTAMP_NS = "TIMESTAMP_NS"
+    TIMESTAMP_MS = "TIMESTAMP_MS"
+    TIMESTAMP_SEC = "TIMESTAMP_SEC"
+    INTERVAL = "INTERVAL"
+    INTERNAL_ID = "INTERNAL_ID"
+    STRING = "STRING"
+    BLOB = "BLOB"
+    UUID = "UUID"
+    LIST = "LIST"
+    ARRAY = "ARRAY"
+    STRUCT = "STRUCT"
+    MAP = "MAP"
+    UNION = "UNION"

real_ladybug-0.0.1.dev1.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: real_ladybug
+Version: 0.0.1.dev1
+Summary: Highly scalable, extremely fast, easy-to-use embeddable graph database
+Home-page: https://github.com/lbugdb/lbug
+License: MIT
+Project-URL: Homepage, https://lbugdb.com/
+Project-URL: Documentation, https://docs.ladybugdb.com/
+Project-URL: Repository, https://github.com/lbugdb/lbug
+Project-URL: Changelog, https://github.com/LadybugDB/ladybug/releases
+Keywords: graph,database
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+  <picture>
+    <!-- <source srcset="https://ladybugdb.com/img/lbug-logo-dark.png" media="(prefers-color-scheme: dark)"> -->
+    <img src="https://ladybugdb.com/logo.png" height="100" alt="Ladybug Logo">
+  </picture>
+</div>
+
+<br>
+
+<p align="center">
+  <a href="https://github.com/LadybugDB/ladybug/actions">
+    <img src="https://github.com/LadybugDB/ladybug/actions/workflows/ci-workflow.yml/badge.svg?branch=master" alt="Github Actions Badge"></a>
+  <a href="https://discord.gg/VtX2gw9Rug">
+    <img src="https://img.shields.io/discord/1196510116388806837?logo=discord" alt="discord" /></a>
+  <a href="https://twitter.com/lbugdb">
+    <img src="https://img.shields.io/badge/follow-@lbugdb-1DA1F2?logo=twitter" alt="twitter"></a>
+</p>
+
+# Ladybug
+Ladybug is an embedded graph database built for query speed and scalability. Ladybug is optimized for handling complex analytical workloads
+on very large databases and provides a set of retrieval features, such as a full text search and vector indices. Our core feature set includes:
+
+- Flexible Property Graph Data Model and Cypher query language
+- Embeddable, serverless integration into applications
+- Native full text search and vector index
+- Columnar disk-based storage
+- Columnar sparse row-based (CSR) adjacency list/join indices
+- Vectorized and factorized query processor
+- Novel and very fast join algorithms
+- Multi-core query parallelism
+- Serializable ACID transactions
+- Wasm (WebAssembly) bindings for fast, secure execution in the browser
+
+Ladybug is being developed by [LadybugDB Developers](https://github.com/LadybugDB) and
+is available under a permissible license. So try it out and help us make it better! We welcome your feedback and feature requests.
+
+The database was formerly known as [Kuzu](https://github.com/kuzudb/kuzu).
+
+## Installation
+
+> [!WARNING]
+> Many of these binary installation methods are not functional yet. We need to work through package names, availability and convention issues.
+> For now, use the build from source method.
+
+| Language | Installation                                                           |
+| -------- |------------------------------------------------------------------------|
+| Python   | `pip install lbug`                                                     |
+| NodeJS   | `npm install lbug`                                                     |
+| Rust     | `cargo add lbug`                                                       |
+| Go       | `go get github.com/lbugdb/go-lbug`                                     |
+| Swift    | [lbug-swift](https://github.com/lbugdb/lbug-swift)                     |
+| Java     | [Maven Central](https://central.sonatype.com/artifact/com.lbugdb/lbug) |
+| C/C++    | [precompiled binaries](https://github.com/LadybugDB/ladybug/releases/latest) |
+| CLI      | [precompiled binaries](https://github.com/LadybugDB/ladybug/releases/latest) |
+
+To learn more about installation, see our [Installation](https://docs.ladybugdb.com/installation) page.
+
+## Getting Started
+
+Refer to our [Getting Started](https://docs.ladybugdb.com/get-started/) page for your first example.
+
+## Build from Source
+
+You can build from source using the instructions provided in the [developer guide](https://kuzudb.github.io/docs/developer-guide/).
+
+## Contributing
+We welcome contributions to Ladybug. If you are interested in contributing to Ladybug, please read our [Contributing Guide](CONTRIBUTING.md).
+
+## License
+By contributing to Ladybug, you agree that your contributions will be licensed under the [MIT License](LICENSE).
+
+## Contact
+You can contact us at [social@ladybugdb.com](mailto:social@ladybugdb.com) or [join our Discord community](https://discord.com/invite/hXyHmvW3Vy).

real_ladybug-0.0.1.dev1.dist-info/RECORD

@@ -0,0 +1,102 @@
+real_ladybug/__init__.py,sha256=lcW8k4wxuQisQ7in7YRy8B60JoevKfThSBwAlp3kT-8,2244
+real_ladybug/_lbug.cp310-win_amd64.pyd,sha256=AAhuPPQ0xr1dGN8jFseRVcXZuRcQ-TmtaAkDn_0Sopo,12816384
+real_ladybug/_lbug.exp,sha256=89SD1NAPBOGGKUPWSr5bVp0ahmllcsuqlgyVA1cj9NI,1113740
+real_ladybug/_lbug.lib,sha256=kOg1-tHdboWEmw0nU-Zxu-Igz9zny1DDXXdyUrFhf9I,1874300
+real_ladybug/async_connection.py,sha256=_64aLqmE9MkMAOy7qh99WY5urYbSDZcsLesqlVFiyUs,7465
+real_ladybug/connection.py,sha256=IrPjgz1odgsS4dlFZign9ccU6AQHT96bwDoZqxYJW_I,10379
+real_ladybug/constants.py,sha256=IzrMthj1ekgloHGqaI_F-hGLLUK8vHbUvH59Cl7YxJE,133
+real_ladybug/database.py,sha256=cuNAR3kyiS4HRUtElh-MdceWmpsF7Kuj2McOLWjen4c,11156
+real_ladybug/prepared_statement.py,sha256=5m_ZZ5Sdqpo-SxnG6RZEsxIu3hfXxl-ave06OSGXz7E,1397
+real_ladybug/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+real_ladybug/query_result.py,sha256=VCe4JVT5vvnFoqZSJ-qsRk8aylH7Nd1lYuJXiJ_Ql_A,16690
+real_ladybug/torch_geometric_feature_store.py,sha256=ek_R6bLi8u8vM8lL-qn-qS5cDak_2AhxwtYLFnUzjjM,7586
+real_ladybug/torch_geometric_graph_store.py,sha256=8IdZy_D3Pc9le_rJo1cn_hBqqmRZNHeWc8fV1mMcwQs,4893
+real_ladybug/torch_geometric_result_converter.py,sha256=L1KG9DnfgrMVpRIvU80Jzry1FahP6cCBMlxZroBk2CA,13476
+real_ladybug/types.py,sha256=T5i3eO5Gj4vRo0g2U3FJD1mSZXLoV37gXHQGaCxMEmU,839
+real_ladybug-0.0.1.dev1.dist-info/licenses/LICENSE,sha256=x6ySSxUOwYqdnHE2qM1TO8-jMQnqe0t3EuqVKiRRhrA,1072
+real_ladybug-source/scripts/collect-extensions.py,sha256=jdV2KPAS8TYg2tJTcJWla1QeIGQihmVS21C5JusGtDM,2182
+real_ladybug-source/scripts/collect-single-file-header.py,sha256=fP92v5MUrHBeIX20ollI8Hhjt2Qe0iDcvQqPzt2UNW0,4677
+real_ladybug-source/scripts/export-dbs.py,sha256=YPOz4ST80_-YEQuxedVLu5MXU3qdp3_fqVmNHsesYwc,3331
+real_ladybug-source/scripts/export-import-test.py,sha256=BF0Mk3EN66D4FlzNHLbtjhFLvx3zLX9u2OafQjjbG9g,11624
+real_ladybug-source/scripts/generate-tinysnb.py,sha256=5hhO8nwqf7hRGRR80y9chvLA0iI9STG4Co7GZNAO-Ag,1023
+real_ladybug-source/scripts/get-clangd-diagnostics.py,sha256=qh-S0mn27yMvXGU4MJ92GY3nn6rd3GoJya8etEx1n9s,6998
+real_ladybug-source/scripts/migrate-lbug-db.py,sha256=UnNMEtVTXwFVinW53YWuDYIANcbmtcqNoTwyAvIee7E,11513
+real_ladybug-source/scripts/run-clang-format.py,sha256=qKr6YxDuFSPRvl86PMEjmkc72_CMIwFDZAMR-DcUd5Q,12359
+real_ladybug-source/scripts/setup-extension-repo.py,sha256=jsDvrulaGJRmP2VJm4yjlnEzKQFoD2BtIFldEhNtEJ0,2141
+real_ladybug-source/scripts/test-simsimd-dispatch.py,sha256=uakf0oSCcmVBO0mOksY1yTzxQn4qqHOYMu3jCZeJq1o,1438
+real_ladybug-source/scripts/update-nightly-build-version.py,sha256=cbND07czA1sSi0ikpXATQ-KGy8orCxhcB-SrpbToeh0,3615
+real_ladybug-source/scripts/antlr4/hash.py,sha256=ExtbZ7b3_3ZKAu0oct_q8LowcaqfYNn3oRknfSBY8Jo,126
+real_ladybug-source/scripts/antlr4/keywordhandler.py,sha256=xxbGSflUnI-yYJ78MY6h94UVddd8oj6KhMJPlxToAXE,1657
+real_ladybug-source/scripts/extension/purge-beta.py,sha256=yx_wu873gG1l9SAtGdge4Jid_oXXc-FXk_4Z9HFxNZQ,948
+real_ladybug-source/scripts/generate-cpp-docs/collect_files.py,sha256=R8HxDCHxw0q1eOQtAzU-YUBy92aOVBFwhUYJikdNW8Q,4738
+real_ladybug-source/scripts/multiplatform-test-helper/collect-results.py,sha256=lhVKdT5zjfJpk29QCsMnF-wWsHjAv7pSABjFlBxmQVA,2254
+real_ladybug-source/scripts/multiplatform-test-helper/notify-discord.py,sha256=WEK8vCzDSF_DpsacRhCMun9E7pkMAqkNmko0FaBicSs,2207
+real_ladybug-source/scripts/pip-package/package_tar.py,sha256=pfmifd4ak6naJ_JVNU4sEIbIuvta_QGMFqhWWbe25j0,3543
+real_ladybug-source/scripts/pip-package/setup.py,sha256=FlAH3RCuWh_4ehcufmKKnXABiHmgR0KFZdiAosd3ju4,5147
+real_ladybug-source/third_party/brotli/scripts/dictionary/step-01-download-rfc.py,sha256=AL67WCT8tszzxfQ-kJ_V_4eS_9cwB_Slj_zIL8kDbCw,375
+real_ladybug-source/third_party/brotli/scripts/dictionary/step-02-rfc-to-bin.py,sha256=-8qEs10jTUa6lTYkWoWhD6o3GztZKN_UA7h0Paq4TJw,882
+real_ladybug-source/third_party/brotli/scripts/dictionary/step-03-validate-bin.py,sha256=Y9xwtVwaxxmt337q_02qTbD1lVl_aUEZYIeZW7alfhY,875
+real_ladybug-source/third_party/brotli/scripts/dictionary/step-04-generate-java-literals.py,sha256=IyBqPr0oG2TyUaBCKO5BE27OGg5fq1q2cn1qDdC8LnY,2214
+real_ladybug-source/third_party/pybind11/tools/codespell_ignore_lines_from_errors.py,sha256=rf-frzFTrUyfZ9PsnJbbhirTRGOaL48gXDhH-ba68e0,1040
+real_ladybug-source/third_party/pybind11/tools/libsize.py,sha256=3MBZDCi0-kdKei_6RcTbmVJgtmT4udB-WIF-mOPLBD4,1031
+real_ladybug-source/third_party/pybind11/tools/make_changelog.py,sha256=nvL4LRhLsDMe7y2U9tvN0s8qCidXVoliW6yd5zAzDB8,1282
+real_ladybug-source/tools/python_api/src_py/__init__.py,sha256=lcW8k4wxuQisQ7in7YRy8B60JoevKfThSBwAlp3kT-8,2244
+real_ladybug-source/tools/python_api/src_py/async_connection.py,sha256=_64aLqmE9MkMAOy7qh99WY5urYbSDZcsLesqlVFiyUs,7465
+real_ladybug-source/tools/python_api/src_py/connection.py,sha256=IrPjgz1odgsS4dlFZign9ccU6AQHT96bwDoZqxYJW_I,10379
+real_ladybug-source/tools/python_api/src_py/constants.py,sha256=IzrMthj1ekgloHGqaI_F-hGLLUK8vHbUvH59Cl7YxJE,133
+real_ladybug-source/tools/python_api/src_py/database.py,sha256=cuNAR3kyiS4HRUtElh-MdceWmpsF7Kuj2McOLWjen4c,11156
+real_ladybug-source/tools/python_api/src_py/prepared_statement.py,sha256=5m_ZZ5Sdqpo-SxnG6RZEsxIu3hfXxl-ave06OSGXz7E,1397
+real_ladybug-source/tools/python_api/src_py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+real_ladybug-source/tools/python_api/src_py/query_result.py,sha256=VCe4JVT5vvnFoqZSJ-qsRk8aylH7Nd1lYuJXiJ_Ql_A,16690
+real_ladybug-source/tools/python_api/src_py/torch_geometric_feature_store.py,sha256=ek_R6bLi8u8vM8lL-qn-qS5cDak_2AhxwtYLFnUzjjM,7586
+real_ladybug-source/tools/python_api/src_py/torch_geometric_graph_store.py,sha256=8IdZy_D3Pc9le_rJo1cn_hBqqmRZNHeWc8fV1mMcwQs,4893
+real_ladybug-source/tools/python_api/src_py/torch_geometric_result_converter.py,sha256=L1KG9DnfgrMVpRIvU80Jzry1FahP6cCBMlxZroBk2CA,13476
+real_ladybug-source/tools/python_api/src_py/types.py,sha256=T5i3eO5Gj4vRo0g2U3FJD1mSZXLoV37gXHQGaCxMEmU,839
+real_ladybug-source/tools/python_api/test/conftest.py,sha256=RDVltlqGKLyCdDJ4CxH-qBwxQN86Mui3FwT7mBgOOho,6922
+real_ladybug-source/tools/python_api/test/disabled_test_extension.py,sha256=6eS1J9lzTjM-LBOz-x6qmPaaEjvOy-nhJDm0G-a4xwc,2571
+real_ladybug-source/tools/python_api/test/ground_truth.py,sha256=jEaE0mF5nXiaTmtURURIHjg970hNLtmbQd_b4h6lPWM,14487
+real_ladybug-source/tools/python_api/test/test_arrow.py,sha256=WHTFMCM94t4ATiV5xTy8TTzZu6Jd5zKAhE7Ko_igOqc,25670
+real_ladybug-source/tools/python_api/test/test_async_connection.py,sha256=VNLKkWZuQfoqQu2OmVI4aO57DvKYJAY-lgCF_PLkqrY,5532
+real_ladybug-source/tools/python_api/test/test_blob_parameter.py,sha256=3Ld4_qyfa1_qYs8jHuZV8zjNPA3hQr3ePIz1opLiw0I,4528
+real_ladybug-source/tools/python_api/test/test_connection.py,sha256=hNWWUXbSmnsACIrxUsPQZ97yh4W67z-bEHj90N5cLs0,1477
+real_ladybug-source/tools/python_api/test/test_database.py,sha256=_ewKmTHsVgInyVWOQphvOKxfpsChcjEmmz6j70EyaTU,8985
+real_ladybug-source/tools/python_api/test/test_datatype.py,sha256=DWgfZEFzOpJWKeYfCIFdDErxaVBD2sUHwI3bgGqn51g,12831
+real_ladybug-source/tools/python_api/test/test_df.py,sha256=-__k7KWwQD0Hz1CEP4nGAhSaECODsjl_V6_KHS2Uoyg,20777
+real_ladybug-source/tools/python_api/test/test_dict.py,sha256=FgfRvhUUOIvbXBXMfvp3BYWko_8L2jJA5fIoRCkWgEg,3850
+real_ladybug-source/tools/python_api/test/test_exception.py,sha256=-kZet73Nx5V6wzZM-67MxCbXP7qTSD86KsoIK6BozM4,2066
+real_ladybug-source/tools/python_api/test/test_fsm.py,sha256=ZnLH_MwWqf5JpXocTi1cqAf6hwOqHmK2Zt6EZHm4rIo,9185
+real_ladybug-source/tools/python_api/test/test_get_header.py,sha256=dBr6qQLKnZ2Rs2GfXqgCgDhyzwwvDCR_j33VFQKr92Q,1944
+real_ladybug-source/tools/python_api/test/test_helper.py,sha256=qV4oDZjVTfmhlp2xcye2Dhx1_q3Chtv4f2EMf-wx6IU,222
+real_ladybug-source/tools/python_api/test/test_issue.py,sha256=X3wCoLRFtAN7ktw6oiZS9j26Vk3BNJpLa_hIGZ9kbT8,4810
+real_ladybug-source/tools/python_api/test/test_iteration.py,sha256=wtOB6bFQSUDageDgOtG4sXGP0Py6NUuMP9vVIm3kKp8,2919
+real_ladybug-source/tools/python_api/test/test_networkx.py,sha256=qZewLif-Oz08_SpRQej60i_tXBqyoGgcfKPdTmBaE3s,13608
+real_ladybug-source/tools/python_api/test/test_parameter.py,sha256=strs22Pd8dS14aDsnSnLyaaA8_O9QugeWKaQo2cx1G8,12486
+real_ladybug-source/tools/python_api/test/test_prepared_statement.py,sha256=vINOcbcPvRiRboiqmUFH5lryZZS_hxJQay6BM6kXB2w,4150
+real_ladybug-source/tools/python_api/test/test_query_result.py,sha256=p9Rupb1iMubodsVFUUrBKws7mnCCSCjqYM3ad6nrI7E,1774
+real_ladybug-source/tools/python_api/test/test_query_result_close.py,sha256=85UEZcniJPwhNmrLPU6MTDt2Q5s4UeTioAFw-Kp7PPI,1346
+real_ladybug-source/tools/python_api/test/test_scan_pandas.py,sha256=74XZswgLxZCpNsA9ucZo729Sk9pOEXchMaRaLsLQoKQ,26455
+real_ladybug-source/tools/python_api/test/test_scan_pandas_pyarrow.py,sha256=jW5EbKE1X9nKVl568apZpXeD12cS6XuRezlK-o9L7CE,28486
+real_ladybug-source/tools/python_api/test/test_scan_polars.py,sha256=dVdRF5-RcA-IzTsFYKjEO5LTkKOvXrrKskygzjwoX2E,6595
+real_ladybug-source/tools/python_api/test/test_scan_pyarrow.py,sha256=MnfYCyNlj8hpekstrubDfvFLG9jYPsvClcLNYrKz67o,6652
+real_ladybug-source/tools/python_api/test/test_timeout.py,sha256=PKMEh4OA7g6qeN9F_j5mxDN1kCtSiKGruDGC2ouTW3Q,363
+real_ladybug-source/tools/python_api/test/test_torch_geometric.py,sha256=BrJi8KF9aRerimqn2_NjqmpydG2zo6WHV247B41JVBM,30362
+real_ladybug-source/tools/python_api/test/test_torch_geometric_remote_backend.py,sha256=__w7r1saXPZjiiTQgMSfdS9bH98kSQMY6NUBqbPg31o,4245
+real_ladybug-source/tools/python_api/test/test_udf.py,sha256=ftm35d89YDHmsgPEhVlrzKaQBRgOWUBS3ljq5Zo5Gjg,7065
+real_ladybug-source/tools/python_api/test/test_version.py,sha256=p1t8Gqffh_NcXXgjcBki4rsa-zohh7fE5-ZWUytYw8w,161
+real_ladybug-source/tools/python_api/test/test_wal.py,sha256=C_iVF6MWqvxWrRL3aGcA6FvOVamy5Xw8jn9WyFMa-is,2896
+real_ladybug-source/tools/python_api/test/type_aliases.py,sha256=CujWOXsU6nuone3YXiKhSdJxyxdQ1QVpvdxwMX4l_YU,223
+real_ladybug-source/tools/rust_api/update_version.py,sha256=du_9SWrPKUEQb0MtDqc304D6uVgn90_Mbu4CIThE6aM,1730
+real_ladybug-source/tools/shell/test/conftest.py,sha256=B1GqWctbDe6WMGE1NF10_zXCbz2b5ruQ4vcqmrhy10Q,5922
+real_ladybug-source/tools/shell/test/test_helper.py,sha256=r05MnCzdWgXg1JO0NVifxyimzKxIlT2LU_62xfEC6iA,1393
+real_ladybug-source/tools/shell/test/test_shell_basics.py,sha256=mmj-4ZrW7JWll15LbTCblFTf7ERKGzDZLpYfne0aScM,10657
+real_ladybug-source/tools/shell/test/test_shell_commands.py,sha256=fTpeA6UYNVsGmmjuPOqcbbPFj6bdpYGvpJGNTpvPjbc,20897
+real_ladybug-source/tools/shell/test/test_shell_control_edit.py,sha256=wo5iG9jtQPG2ld9iB87gW2OHud5LcDo4R5abln-TwFg,15220
+real_ladybug-source/tools/shell/test/test_shell_control_search.py,sha256=oDVwX7dTYa0ysdDXzIqQB1G1C9BV26J-oDcW8QNlepo,15720
+real_ladybug-source/tools/shell/test/test_shell_esc_edit.py,sha256=3Yp1jWcX3phWstXkVhfQy7FimTLql7MyAfXKmqvrWO4,7782
+real_ladybug-source/tools/shell/test/test_shell_esc_search.py,sha256=QiI2cukOvSkTaA_5tmOJyVKD0FJre1YwTKKPl-3PD2k,5178
+real_ladybug-source/tools/shell/test/test_shell_flags.py,sha256=Kn-sHCmX1yYsm6iz1XTHZOVm-DlcILV7n71ssWUwnTs,19260
+real_ladybug-0.0.1.dev1.dist-info/METADATA,sha256=WPRVJwjAUWngEOpOIjEIXWxT44xkOUbk7SyryVH9jMk,4354
+real_ladybug-0.0.1.dev1.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+real_ladybug-0.0.1.dev1.dist-info/top_level.txt,sha256=Ghr-PDj7X7c8FPfqZnnX9-p6VwzxGrhGp5U28_vFfQ4,33
+real_ladybug-0.0.1.dev1.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+real_ladybug-0.0.1.dev1.dist-info/RECORD,,

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: cp310-cp310-win_amd64
+