phenolrs 0.5.9__cp312-cp312-win_amd64.whl

phenolrs/__init__.py

@@ -0,0 +1,5 @@
+from .phenolrs import *  # noqa: F403
+
+__doc__ = phenolrs.__doc__  # type: ignore[name-defined]  # noqa: F405
+if hasattr(phenolrs, "__all__"):  # type: ignore[name-defined]  # noqa: F405
+    __all__ = phenolrs.__all__  # type: ignore[name-defined]  # noqa: F405

phenolrs/networkx/__init__.py

@@ -0,0 +1 @@
+from .loader import NetworkXLoader  # noqa: F401

phenolrs/networkx/loader.py

@@ -0,0 +1,144 @@
+from typing import Any, Set, Tuple
+
+from phenolrs import PhenolError, graph_to_networkx_format
+
+from .typings import (
+    ArangoIDtoIndex,
+    DiGraphAdjDict,
+    DstIndices,
+    EdgeIndices,
+    EdgeValuesDict,
+    GraphAdjDict,
+    MultiDiGraphAdjDict,
+    MultiGraphAdjDict,
+    NodeDict,
+    SrcIndices,
+)
+
+
+class NetworkXLoader:
+    @staticmethod
+    def load_into_networkx(
+        database: str,
+        metagraph: dict[str, dict[str, Set[str]]],
+        hosts: list[str],
+        user_jwt: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        tls_cert: Any | None = None,
+        parallelism: int | None = None,
+        batch_size: int | None = None,
+        load_adj_dict: bool = True,
+        load_coo: bool = True,
+        load_all_vertex_attributes: bool = True,
+        load_all_edge_attributes: bool = True,
+        is_directed: bool = True,
+        is_multigraph: bool = True,
+        symmetrize_edges_if_directed: bool = False,
+    ) -> Tuple[
+        NodeDict,
+        GraphAdjDict | DiGraphAdjDict | MultiGraphAdjDict | MultiDiGraphAdjDict,
+        SrcIndices,
+        DstIndices,
+        EdgeIndices,
+        ArangoIDtoIndex,
+        EdgeValuesDict,
+    ]:
+        if "vertexCollections" not in metagraph:
+            raise PhenolError("vertexCollections not found in metagraph")
+
+        if "edgeCollections" not in metagraph:
+            raise PhenolError("edgeCollections not found in metagraph")
+
+        if len(metagraph["vertexCollections"]) + len(metagraph["edgeCollections"]) == 0:
+            m = "vertexCollections and edgeCollections cannot both be empty"
+            raise PhenolError(m)
+
+        if len(metagraph["edgeCollections"]) == 0 and (load_adj_dict or load_coo):
+            m = "edgeCollections must be non-empty if **load_adj_dict** or **load_coo** is True"  # noqa
+            raise PhenolError(m)
+
+        if load_all_vertex_attributes and any(
+            [len(entries) > 0 for entries in metagraph["vertexCollections"].values()]
+        ):
+            m = "load_all_vertex_attributes is True, but vertexCollections contain attributes"  # noqa
+            raise PhenolError(m)
+
+        if load_all_edge_attributes and any(
+            [len(entries) > 0 for entries in metagraph["edgeCollections"].values()]
+        ):
+            m = "load_all_edge_attributes is True, but edgeCollections contain attributes"  # noqa
+            raise PhenolError(m)
+
+        if len(metagraph["edgeCollections"]) != 0 and not (load_coo or load_adj_dict):
+            m = "load_coo and load_adj_dict cannot both be False if edgeCollections is non-empty"  # noqa
+            raise PhenolError(m)
+
+        # TODO: replace with pydantic validation
+        db_config_options: dict[str, Any] = {
+            "endpoints": hosts,
+            "database": database,
+        }
+
+        load_config_options: dict[str, Any] = {
+            "parallelism": parallelism if parallelism is not None else 8,
+            "batch_size": batch_size if batch_size is not None else 100000,
+            "prefetch_count": 5,
+            "load_all_vertex_attributes": load_all_vertex_attributes,
+            "load_all_edge_attributes": load_all_edge_attributes,
+        }
+
+        if username:
+            db_config_options["username"] = username
+        if password:
+            db_config_options["password"] = password
+        if user_jwt:
+            db_config_options["jwt_token"] = user_jwt
+        if tls_cert:
+            db_config_options["tls_cert"] = tls_cert
+
+        graph_config = {
+            "load_adj_dict": load_adj_dict,
+            "load_coo": load_coo,
+            "is_directed": is_directed,
+            "is_multigraph": is_multigraph,
+            "symmetrize_edges_if_directed": symmetrize_edges_if_directed,
+        }
+
+        vertex_collections = [
+            {"name": v_col_name, "fields": list(entries)}
+            for v_col_name, entries in metagraph["vertexCollections"].items()
+        ]
+
+        edge_collections = [
+            {"name": e_col_name, "fields": list(entries)}
+            for e_col_name, entries in metagraph["edgeCollections"].items()
+        ]
+
+        (
+            node_dict,
+            adj_dict,
+            src_indices,
+            dst_indices,
+            edge_indices,
+            id_to_index_map,
+            edge_values,
+        ) = graph_to_networkx_format(
+            request={
+                "vertex_collections": vertex_collections,
+                "edge_collections": edge_collections,
+                "database_config": db_config_options,
+                "load_config": load_config_options,
+            },
+            graph_config=graph_config,  # TODO Anthony: Move into request
+        )
+
+        return (
+            node_dict,
+            adj_dict,
+            src_indices,
+            dst_indices,
+            edge_indices,
+            id_to_index_map,
+            edge_values,
+        )

phenolrs/networkx/typings.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+Json = dict[str, Any]
+NodeDict = dict[str, Json]
+GraphAdjDict = dict[str, dict[str, Json]]
+DiGraphAdjDict = dict[str, GraphAdjDict]
+MultiGraphAdjDict = dict[str, dict[str, dict[int, Json]]]
+MultiDiGraphAdjDict = dict[str, MultiGraphAdjDict]
+EdgeValuesDict = dict[str, list[int | float]]
+
+SrcIndices = npt.NDArray[np.int64]
+DstIndices = npt.NDArray[np.int64]
+EdgeIndices = npt.NDArray[np.int64]
+ArangoIDtoIndex = dict[str, int]

phenolrs/numpy/__init__.py

@@ -0,0 +1 @@
+from .loader import NumpyLoader  # noqa: F401

phenolrs/numpy/loader.py

@@ -0,0 +1,114 @@
+from typing import Any, Tuple
+
+from phenolrs import PhenolError, graph_to_numpy_format
+
+from .typings import (
+    ArangoCollectionSourceToOutput,
+    ArangoCollectionToArangoKeyToIndex,
+    ArangoCollectionToIndexToArangoKey,
+    ArangoCollectionToNodeFeatures,
+    COOByEdgeType,
+)
+
+
+class NumpyLoader:
+    @staticmethod
+    def load_graph_to_numpy(
+        database: str,
+        metagraph: dict[str, Any],
+        hosts: list[str],
+        user_jwt: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        tls_cert: Any | None = None,
+        parallelism: int | None = None,
+        batch_size: int | None = None,
+    ) -> Tuple[
+        ArangoCollectionToNodeFeatures,
+        COOByEdgeType,
+        ArangoCollectionToArangoKeyToIndex,
+        ArangoCollectionToIndexToArangoKey,
+        ArangoCollectionSourceToOutput,
+    ]:
+        # TODO: replace with pydantic validation
+        db_config_options: dict[str, Any] = {
+            "endpoints": hosts,
+            "database": database,
+        }
+        load_config_options: dict[str, Any] = {
+            "parallelism": parallelism if parallelism is not None else 8,
+            "batch_size": batch_size if batch_size is not None else 100000,
+            "prefetch_count": 5,
+            "load_all_vertex_attributes": False,
+            "load_all_edge_attributes": False,
+        }
+        if username:
+            db_config_options["username"] = username
+        if password:
+            db_config_options["password"] = password
+        if user_jwt:
+            db_config_options["jwt_token"] = user_jwt
+        if tls_cert:
+            db_config_options["tls_cert"] = tls_cert
+
+        if "vertexCollections" not in metagraph:
+            raise PhenolError("vertexCollections not found in metagraph")
+
+        # Address the possibility of having something like this:
+        # "USER": {"x": {"features": None}}
+        # Should be converted to:
+        # "USER": {"x": "features"}
+        entries: dict[str, Any]
+        for v_col_name, entries in metagraph["vertexCollections"].items():
+            for source_name, value in entries.items():
+                if isinstance(value, dict):
+                    if len(value) != 1:
+                        m = f"Only one feature field should be specified per attribute. Found {value}"  # noqa: E501
+                        raise PhenolError(m)
+
+                    value_key = list(value.keys())[0]
+                    if value[value_key] is not None:
+                        m = f"Invalid value for feature {source_name}: {value_key}. Found {value[value_key]}"  # noqa: E501
+                        raise PhenolError(m)
+
+                    metagraph["vertexCollections"][v_col_name][source_name] = value_key
+
+        vertex_collections = [
+            {"name": v_col_name, "fields": list(entries.values())}
+            for v_col_name, entries in metagraph["vertexCollections"].items()
+        ]
+        vertex_cols_source_to_output = {
+            v_col_name: {
+                source_name: output_name for output_name, source_name in entries.items()
+            }
+            for v_col_name, entries in metagraph["vertexCollections"].items()
+        }
+
+        edge_collections = []
+        if "edgeCollections" in metagraph:
+            edge_collections = [
+                {"name": e_col_name, "fields": list(entries.values())}
+                for e_col_name, entries in metagraph["edgeCollections"].items()
+            ]
+
+        (
+            features_by_col,
+            coo_map,
+            col_to_adb_key_to_ind,
+            col_to_ind_to_adb_key,
+        ) = graph_to_numpy_format(
+            {
+                "vertex_collections": vertex_collections,
+                "edge_collections": edge_collections,
+                "database_config": db_config_options,
+                "load_config": load_config_options,
+            }
+        )
+
+        return (
+            features_by_col,
+            coo_map,
+            col_to_adb_key_to_ind,
+            col_to_ind_to_adb_key,
+            vertex_cols_source_to_output,
+        )

phenolrs/numpy/typings.py

@@ -0,0 +1,12 @@
+from typing import Tuple
+
+import numpy as np
+import numpy.typing as npt
+
+EdgeType = Tuple[str, str, str]
+
+ArangoCollectionToNodeFeatures = dict[str, dict[str, npt.NDArray[np.float64]]]
+COOByEdgeType = dict[EdgeType, npt.NDArray[np.float64]]
+ArangoCollectionToArangoKeyToIndex = dict[str, dict[str, int]]
+ArangoCollectionToIndexToArangoKey = dict[str, dict[int, str]]
+ArangoCollectionSourceToOutput = dict[str, dict[str, str]]

phenolrs/phenolrs.pyi

@@ -0,0 +1,43 @@
+import typing
+
+import numpy as np
+import numpy.typing as npt
+
+from .networkx.typings import (
+    ArangoIDtoIndex,
+    DiGraphAdjDict,
+    DstIndices,
+    EdgeIndices,
+    EdgeValuesDict,
+    GraphAdjDict,
+    MultiDiGraphAdjDict,
+    MultiGraphAdjDict,
+    NodeDict,
+    SrcIndices,
+)
+from .numpy.typings import (
+    ArangoCollectionToArangoKeyToIndex,
+    ArangoCollectionToIndexToArangoKey,
+    ArangoCollectionToNodeFeatures,
+    COOByEdgeType,
+)
+
+def graph_to_numpy_format(request: dict[str, typing.Any]) -> typing.Tuple[
+    ArangoCollectionToNodeFeatures,
+    COOByEdgeType,
+    ArangoCollectionToArangoKeyToIndex,
+    ArangoCollectionToIndexToArangoKey,
+]: ...
+def graph_to_networkx_format(
+    request: dict[str, typing.Any], graph_config: dict[str, typing.Any]
+) -> typing.Tuple[
+    NodeDict,
+    GraphAdjDict | DiGraphAdjDict | MultiGraphAdjDict | MultiDiGraphAdjDict,
+    SrcIndices,
+    DstIndices,
+    EdgeIndices,
+    ArangoIDtoIndex,
+    EdgeValuesDict,
+]: ...
+
+class PhenolError(Exception): ...

phenolrs/pyg/__init__.py

@@ -0,0 +1 @@
+from .loader import PygLoader  # noqa: F401

phenolrs/pyg/loader.py

@@ -0,0 +1,173 @@
+from typing import Any, Tuple
+
+import numpy as np
+
+from phenolrs import PhenolError
+from phenolrs.numpy import NumpyLoader
+
+from .typings import (
+    ArangoCollectionToArangoKeyToIndex,
+    ArangoCollectionToIndexToArangoKey,
+)
+
+try:
+    import torch
+    from torch_geometric.data import Data, HeteroData
+
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+
+
+class PygLoader:
+    @staticmethod
+    def load_into_pyg_data(
+        database: str,
+        metagraph: dict[str, Any],
+        hosts: list[str],
+        user_jwt: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        tls_cert: Any | None = None,
+        parallelism: int | None = None,
+        batch_size: int | None = None,
+    ) -> Tuple[
+        "Data", ArangoCollectionToArangoKeyToIndex, ArangoCollectionToIndexToArangoKey
+    ]:
+        if not TORCH_AVAILABLE:
+            m = "Missing required dependencies. Install with `pip install phenolrs[torch]`"  # noqa: E501
+            raise ImportError(m)
+
+        if "vertexCollections" not in metagraph:
+            raise PhenolError("vertexCollections not found in metagraph")
+        if "edgeCollections" not in metagraph:
+            raise PhenolError("edgeCollections not found in metagraph")
+
+        if len(metagraph["vertexCollections"]) == 0:
+            raise PhenolError("vertexCollections must map to non-empty dictionary")
+        if len(metagraph["edgeCollections"]) == 0:
+            raise PhenolError("edgeCollections must map to non-empty dictionary")
+
+        if len(metagraph["vertexCollections"]) > 1:
+            m = "More than one vertex collection specified for homogeneous dataset"
+            raise PhenolError(m)
+        if len(metagraph["edgeCollections"]) > 1:
+            m = "More than one edge collection specified for homogeneous dataset"
+            raise PhenolError(m)
+
+        v_col_spec_name = list(metagraph["vertexCollections"].keys())[0]
+        v_col_spec = list(metagraph["vertexCollections"].values())[0]
+
+        (
+            features_by_col,
+            coo_map,
+            col_to_adb_key_to_ind,
+            col_to_ind_to_adb_key,
+            vertex_cols_source_to_output,
+        ) = NumpyLoader.load_graph_to_numpy(
+            database,
+            metagraph,
+            hosts,
+            user_jwt,
+            username,
+            password,
+            tls_cert,
+            parallelism,
+            batch_size,
+        )
+
+        data = Data()
+        # add the features
+        if v_col_spec_name not in features_by_col:
+            raise PhenolError(f"Unable to load data for collection {v_col_spec_name}")
+        for feature in v_col_spec.keys():
+            feature_source_key = v_col_spec[feature]
+            if feature_source_key not in features_by_col[v_col_spec_name]:
+                raise PhenolError(
+                    f"Unable to load features {feature_source_key} for collection {v_col_spec_name}"  # noqa: E501
+                )
+            result = torch.from_numpy(
+                features_by_col[v_col_spec_name][feature_source_key].astype(np.float64)
+            )
+            if result.numel() > 0:
+                data[feature] = result
+
+        # finally add the edges
+        edge_col_name = list(metagraph["edgeCollections"].keys())[0]
+        for e_tup in coo_map.keys():
+            e_name, from_name, to_name = e_tup
+            if e_name == edge_col_name:
+                result = torch.from_numpy(coo_map[e_tup].astype(np.int64))
+                if result.numel() > 0:
+                    data["edge_index"] = result
+
+        return data, col_to_adb_key_to_ind, col_to_ind_to_adb_key
+
+    @staticmethod
+    def load_into_pyg_heterodata(
+        database: str,
+        metagraph: dict[str, Any],
+        hosts: list[str],
+        user_jwt: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        tls_cert: Any | None = None,
+        parallelism: int | None = None,
+        batch_size: int | None = None,
+    ) -> tuple[
+        "HeteroData",
+        ArangoCollectionToArangoKeyToIndex,
+        ArangoCollectionToIndexToArangoKey,
+    ]:
+        if not TORCH_AVAILABLE:
+            m = "Missing required dependencies. Install with `pip install phenolrs[torch]`"  # noqa: E501
+            raise ImportError(m)
+
+        if "vertexCollections" not in metagraph:
+            raise PhenolError("vertexCollections not found in metagraph")
+        if "edgeCollections" not in metagraph:
+            raise PhenolError("edgeCollections not found in metagraph")
+
+        if len(metagraph["vertexCollections"]) == 0:
+            raise PhenolError("vertexCollections must map to non-empty dictionary")
+        if len(metagraph["edgeCollections"]) == 0:
+            raise PhenolError("edgeCollections must map to non-empty dictionary")
+
+        (
+            features_by_col,
+            coo_map,
+            col_to_adb_key_to_ind,
+            col_to_ind_to_adb_key,
+            vertex_cols_source_to_output,
+        ) = NumpyLoader.load_graph_to_numpy(
+            database,
+            metagraph,
+            hosts,
+            user_jwt,
+            username,
+            password,
+            tls_cert,
+            parallelism,
+            batch_size,
+        )
+        data = HeteroData()
+        for col in features_by_col.keys():
+            col_mapping = vertex_cols_source_to_output[col]
+            for feature in features_by_col[col].keys():
+                if feature == "@collection_name":
+                    continue
+
+                target_name = col_mapping[feature]
+                result = torch.from_numpy(
+                    features_by_col[col][feature].astype(np.float64)
+                )
+                if result.numel() > 0:
+                    data[col][target_name] = result
+
+        for edge_col in coo_map.keys():
+            edge_col_name, from_name, to_name = edge_col
+            result = torch.from_numpy(coo_map[edge_col].astype(np.int64))
+            if result.numel() > 0:
+                data[(from_name, edge_col_name, to_name)].edge_index = result
+
+        return data, col_to_adb_key_to_ind, col_to_ind_to_adb_key

phenolrs/pyg/typings.py

@@ -0,0 +1,2 @@
+ArangoCollectionToArangoKeyToIndex = dict[str, dict[str, int]]
+ArangoCollectionToIndexToArangoKey = dict[str, dict[int, str]]

phenolrs-0.5.9.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: phenolrs
+Version: 0.5.9
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Dist: numpy ~=1.26
+Requires-Dist: python-arango
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: arango-datasets ; extra == 'tests'
+Requires-Dist: adbnx-adapter ; extra == 'tests'
+Requires-Dist: torch ; extra == 'torch'
+Requires-Dist: torch-geometric ; extra == 'torch'
+Requires-Dist: version ; extra == 'dynamic'
+Provides-Extra: tests
+Provides-Extra: torch
+Provides-Extra: dynamic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Phenolrs
+
+## Running/building
+
+### Required:
+- `python`
+- `pytest`
+- `rust/cargo`
+
+### Build
+Build using the `maturin` python package - can install using `pip install maturin`.
+
+Dev build
+`maturin develop`
+
+Release build
+`maturin develop -r`
+
+### Tests
+
+#### Rust
+`cargo test --no-default-features`
+
+#### Python
+** WIP - assumes dataset loaded in local ArangoDB instance. **
+
+##### Requirements
+`pip install pytest arango-datasets`
+
+##### Python db setup
+```python
+import arango
+from arango_datasets import Datasets
+
+client = arango.ArangoClient("http://localhost:8529")
+sys = client.db("_system", password="test")
+sys.create_database("abide")
+
+abide_db = client.db("abide", password="test")
+dsets = Datasets(abide_db)
+dsets.load("ABIDE")
+```
+
+##### Run python tests:
+`maturin develop && pytest`
+

phenolrs-0.5.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+phenolrs-0.5.9.dist-info/METADATA,sha256=PG7Nvsxl83OYRTNQencyHIZWk9Kjnmr7Hf34GCMkVZQ,1750
+phenolrs-0.5.9.dist-info/WHEEL,sha256=2fdNHxJvS2bAcI00delQ4QrnR7Oujl4cP2y-SRm5elU,96
+phenolrs/networkx/loader.py,sha256=HTC1fuIKWgPZATnHsnQlmJcoQ973Gke0G12pS-A1w6g,5053
+phenolrs/networkx/typings.py,sha256=-_Bdpwpxj9eKAjnNKoK0XMRs3rT6z16kw5mH53k7kd8,515
+phenolrs/networkx/__init__.py,sha256=IkJSMrsv-Ky3uviyX5uIBJXlALnpz_PKE-OlQpxTJko,50
+phenolrs/numpy/loader.py,sha256=V5rKbhrCsPx_Ynapo8-ROQlNVBZhniGf_g0IPqvQ5ZA,4203
+phenolrs/numpy/typings.py,sha256=JcKbwXwNkgOUIAOBan9SRNeHH3QkvPqDBzFGHhaYLWs,438
+phenolrs/numpy/__init__.py,sha256=gx3JCZ0u9RPDUthbaa2n4GnyklRwwgMyCOWjKlWT43M,47
+phenolrs/phenolrs.pyi,sha256=6LRUFRdXtL_L_7xZ0xYS83l8Vq07fpT37PAeOvQE1v4,1057
+phenolrs/pyg/loader.py,sha256=STEKl8Wc4TOLh_D0j8CV_BIYjyI-WpBt8xxulhblQ9M,6332
+phenolrs/pyg/typings.py,sha256=e52peJZkW9_QrGpn879hvvNsprBJK4U7aPVsnRUJSf8,128
+phenolrs/pyg/__init__.py,sha256=FyMHHo7XUn48UzGbtcuGo7mLEXOxxQdu-f16hicc6HY,45
+phenolrs/__init__.py,sha256=VFJvgvyWg3kAovAU7Qww4-AjcV2P-BS8vQVBxjYkLjE,267
+phenolrs/phenolrs.cp312-win_amd64.pyd,sha256=nGB4qopIYnQxmie8s55UHrxf5AGK7SO7O5JWrsvMXwg,5609472
+phenolrs-0.5.9.dist-info/RECORD,,

phenolrs-0.5.9.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.1)
+Root-Is-Purelib: false
+Tag: cp312-cp312-win_amd64