GQLAlchemy

https://github.com/memgraph/gqlalchemy
Admin
GQLAlchemy is a Python Object Graph Mapper (OGM) library that enables developers to interact with...
Tokens:72,717
Snippets:846
Trust Score:10
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start and Connect to Memgraph Instance

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-binary-instance.md

Initialize and start a Memgraph binary instance, then establish a connection. Ensure the binary path and user are correctly set, especially for dpkg installations.

```python
memgraph_instance = MemgraphInstanceBinary(
    host="0.0.0.0", port=7698, binary_path="/usr/lib/memgraph/memgraph", user="memgraph"
)
memgraph = memgraph_instance.start_and_connect(restart=False)
```

--------------------------------

### Generate Reference Documentation

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install pydoc-markdown and run it to generate the reference guide from code. This is useful for creating API documentation.

```bash
pip3 install pydoc-markdown

```

```bash
pydoc-markdown

```

--------------------------------

### Install GQLAlchemy with specific extras using uv

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs GQLAlchemy from source with selected optional dependencies using uv. Specify the desired extras to tailor the installation.

```bash
uv sync # No extras
```

```bash
uv sync --extra arrow # Support for the CSV, Parquet, ORC and IPC/Feather/Arrow formats
```

```bash
uv sync --extra dgl # Installs torch (DGL must be installed separately, see below)
```

```bash
uv sync --extra dot # DOT graph import support (pydot)
```

```bash
uv sync --extra docker # Docker support
```

--------------------------------

### Start Memgraph instance with custom configuration flags

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-docker-instance.md

Starts a Memgraph Docker instance with custom configuration flags passed as a dictionary. This example sets the log level to TRACE.

```python
config={"--log-level": "TRACE"}
memgraph_instance = MemgraphInstanceDocker(config=config)
```

--------------------------------

### Build GQLAlchemy from source with uv

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs GQLAlchemy and all optional dependencies from source using the uv package manager. This is a convenient way to get the full feature set.

```bash
uv sync --all-extras
```

--------------------------------

### Install GQLAlchemy with All Extras

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install GQLAlchemy with all available optional features, including Arrow, DGL, and Docker support.

```bash
pip install gqlalchemy[all]
```

--------------------------------

### Install GQLAlchemy with Docker Support

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install GQLAlchemy with Docker integration capabilities.

```bash
pip install gqlalchemy[docker]
```

--------------------------------

### Install pymgclient with pip

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs the pymgclient library, a prerequisite for GQLAlchemy, using pip. Use the --user flag for user-specific installations.

```bash
pip install --user pymgclient
```

--------------------------------

### Install GQLAlchemy with Specific Extras

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Installs GQLAlchemy with selected optional dependencies. Use this to tailor the installation to specific features like Arrow, DGL, Docker, or TFGNN.

```bash
uv sync # No extras
```

```bash
uv sync --extra arrow # Support for the CSV, Parquet, ORC and IPC/Feather/Arrow formats
```

```bash
uv sync --extra dgl # Installs torch (DGL must be installed separately, see below)
```

```bash
uv sync --extra docker # Docker support
```

```bash
uv sync --extra tfgnn # TFGNN support
```

--------------------------------

### Install Memgraph Platform

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/import-python-graphs.md

Installs Memgraph Platform including MAGE and Memgraph Lab. Use the Linux/macOS command for Docker Compose setup or the Windows command for its equivalent.

```bash
curl https://install.memgraph.com | sh
```

```powershell
iwr https://windows.memgraph.com | iex
```

--------------------------------

### Connect to Neo4j (Example)

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/streams/kafka-streams.md

This is an example of how to connect to a Neo4j database using gqlalchemy. It is provided for context on alternative database connections.

```python
db = Neo4j(host="localhost", port="7687", username="neo4j", password="test")
```

--------------------------------

### Install GQLAlchemy with Arrow Support

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install GQLAlchemy with support for CSV, Parquet, ORC, and IPC/Feather/Arrow formats.

```bash
pip install gqlalchemy[arrow]
```

--------------------------------

### Install GQLAlchemy with DGL Support

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install GQLAlchemy with Deep Graph Library (DGL) support. This also includes PyTorch.

```bash
pip install gqlalchemy[dgl]
```

--------------------------------

### Start and connect to a Memgraph Docker instance

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-docker-instance.md

Initializes and starts a Memgraph Docker instance using default settings and establishes a connection. Set restart=True to force a restart if the instance is already running.

```python
memgraph_instance = MemgraphInstanceDocker(
    docker_image=DockerImage.MEMGRAPH, docker_image_tag="latest", host="0.0.0.0", port=7687
)
memgraph = memgraph_instance.start_and_connect(restart=False)
```

--------------------------------

### MemgraphInstance Start and Connect

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/instance_runner.md

Starts a Memgraph instance and returns the connection object. If the instance is already running, it can be restarted if the `restart` flag is set to True.

```python
def start_and_connect(restart: bool = False) -> "Memgraph"
```

--------------------------------

### MemgraphInstance Start

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/instance_runner.md

Starts the Memgraph instance. Use the `restart` parameter to force a restart if the instance is already running.

```python
def start(restart: bool = False) -> None
```

--------------------------------

### MemgraphInstance.start_and_connect

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/instance_runner.md

Starts the Memgraph instance and returns the connection object. Optionally restarts the instance if it's already running.

```APIDOC
## MemgraphInstance.start_and_connect

### Description
Start the Memgraph instance and return the connection object.

### Parameters
#### Attributes
- `restart` (bool) - Optional - A bool indicating if the instance should be restarted if it's already running. Defaults to `False`.

### Returns
- `Memgraph` - The connection object.
```

--------------------------------

### Serve Documentation Locally

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Install MkDocs, the Material theme, and PyMdown extensions, then serve the documentation locally to preview changes. This allows for local testing of documentation.

```bash
pip3 install mkdocs

```

```bash
pip3 install mkdocs-material

```

```bash
pip3 install pymdown-extensions

```

```bash
mkdocs serve

```

--------------------------------

### Install DOT Graph Support

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/import-python-graphs.md

Installs the necessary libraries for importing DOT files using GQLAlchemy, which relies on pydot and NetworkX.

```bash
pip install gqlalchemy[dot]
```

--------------------------------

### MemgraphInstance.start

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/instance_runner.md

Starts the Memgraph instance. Can be configured to restart the instance if it is already running.

```APIDOC
## MemgraphInstance.start

### Description
Start the Memgraph instance.

### Parameters
#### Attributes
- `restart` (bool) - Optional - A bool indicating if the instance should be restarted if it's already running. Defaults to `False`.

### Returns
- `None`
```

--------------------------------

### Install DGL with uv

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs the DGL library using uv, specifying the correct wheel repository for PyTorch 2.4.

```bash
uv sync --extra dgl
uv pip install dgl -f https://data.dgl.ai/wheels/torch-2.4/repo.html
```

--------------------------------

### Install GQLAlchemy with extras via pip

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs GQLAlchemy with additional capabilities for specific formats or libraries. Choose the extras that match your project's needs.

```bash
pip install gqlalchemy[arrow] # Support for the CSV, Parquet, ORC and IPC/Feather/Arrow formats
```

```bash
pip install gqlalchemy[dgl] # DGL support (also includes torch)
```

```bash
pip install gqlalchemy[dot] # DOT graph import support (pydot)
```

```bash
pip install gqlalchemy[docker] # Docker support
```

```bash
pip install gqlalchemy[all] # All of the above
```

--------------------------------

### Full OGM Code Example

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

A comprehensive example demonstrating node and relationship definition, saving, loading, and constraint checking using GQLAlchemy's OGM.

```python
from gqlalchemy import Memgraph, Node, Relationship, Field
from typing import Optional

db = Memgraph()

class User(Node):
    id: str = Field(index=True, db=db)
    username: str = Field(exists=True, db=db)

class Streamer(User):
    id: str
    username: Optional[str] = Field(exists=True, db=db)
    followers: Optional[str]

class Language(Node, index=True, db=db):
    name: str = Field(unique=True, db=db)

class ChatsWith(Relationship, type="CHATS_WITH"):
    last_chatted: str

class Speaks(Relationship, type="SPEAKS"):
    since: Optional[str]

john = User(id="1", username="John").save(db)
jane = Streamer(id="2", username="janedoe", followers=111).save(db)
language = Language(name="en").save(db)

ChatsWith(
    _start_node_id=john._id, _end_node_id=jane._id, last_chatted="2023-02-14"
).save(db)

Speaks(_start_node_id=john._id, _end_node_id=language._id, since="2023-02-14").save(db)

streamer = Streamer(id="2").load(db=db)
language = Language(name="en").load(db=db)

speaks = Speaks(
    _start_node_id=streamer._id,
    _end_node_id=language._id,
    since="2023-02-20",
).save(db)

speaks = Speaks(_start_node_id=streamer._id, _end_node_id=language._id).load(db)
print(speaks.since)

try:
    streamer = Streamer(id="3").load(db=db)
except:
    print("Creating new Streamer node in the database.")
    streamer = Streamer(id="3", username="anne", followers=222).save(db=db)

try:
    speaks = Speaks(_start_node_id=streamer._id, _end_node_id=language._id).load(db)
except:
    print("Creating new Speaks relationship in the database.")
    speaks = Speaks(
        _start_node_id=streamer._id,
        _end_node_id=language._id,
        since="2023-02-20",
    ).save(db)

print(db.get_indexes())
print(db.get_constraints())
```

--------------------------------

### Install GQLAlchemy with PyTorch Geometric support via pip

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs GQLAlchemy with PyTorch Geometric support, including necessary prerequisites. Ensure PyTorch is installed separately if needed.

```bash
pip install gqlalchemy[torch_pyg] # prerequisite
pip install torch-scatter torch-sparse torch-cluster torch-spline-conv torch-geometric -f https://data.pyg.org/whl/torch-1.13.0+cpu.html
```

--------------------------------

### Install GQLAlchemy with pip

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs the default GQLAlchemy package using pip. This provides core functionality without specific import/export features.

```bash
pip install gqlalchemy
```

--------------------------------

### Get Memgraph Build Information

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/manage-database.md

Retrieve build information for the running Memgraph instance, such as the build type and optimization level. Ensure GQLAlchemy is installed and Memgraph is running.

```python
from gqlalchemy import Memgraph

db = Memgraph()

build_info = db.get_build_info()
for item in build_info:
    print(item)
```

--------------------------------

### Run Development Build Commands

Source: https://github.com/memgraph/gqlalchemy/blob/main/README.md

Execute linters, formatters, and tests for development. Ensure you have 'uv' installed for running these commands.

```bash
uv run flake8 .

```

```bash
uv run black .

```

```bash
uv run pytest . -k "not slow and not extras"

```

--------------------------------

### Install GQLAlchemy with extras in zsh

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs GQLAlchemy with extras when using the zsh terminal. The command needs to be enclosed in single quotes to handle the special characters.

```bash
pip install 'gqlalchemy[arrow]'
```

--------------------------------

### Stream Management

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Methods for creating, starting, listing, and dropping database streams.

```python
def create_stream(stream: MemgraphStream) -> None
```

```python
def start_stream(stream: MemgraphStream) -> None
```

```python
def get_streams() -> List[str]
```

```python
def drop_stream(stream: MemgraphStream) -> None
```

--------------------------------

### Install PyTorch Geometric with uv

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Installs PyTorch Geometric and its related scatter, sparse, cluster, and spline convolution libraries using uv, pointing to the correct PyTorch 2.4.0 wheel repository.

```bash
uv sync --extra torch_pyg
uv pip install torch-scatter torch-sparse torch-cluster torch-spline-conv torch-geometric -f https://data.pyg.org/whl/torch-2.4.0+cpu.html
```

--------------------------------

### Get Build Info

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Retrieves build information for the Memgraph instance.

```python
def get_build_info() -> List[dict]
```

--------------------------------

### Run GQLAlchemy tests with uv (specific extras)

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Executes GQLAlchemy tests using uv, excluding slow and general extras. Use this when only specific optional dependencies are installed.

```bash
uv run pytest . -k "not slow and not extras"
```

--------------------------------

### Run GQLAlchemy tests with uv (all extras)

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Executes GQLAlchemy tests using uv, excluding slow tests. This command is suitable when all optional extras have been installed.

```bash
uv run pytest . -k "not slow"
```

--------------------------------

### Load Relationship by Start and End Node IDs

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Load an existing relationship by specifying the IDs of its start and end nodes. The relationship's properties can then be accessed.

```python
class Speaks(Relationship, type="SPEAKS"):
    since: Optional[str]


loaded_speaks = Speaks(
        _start_node_id=streamer._id,
        _end_node_id=language._id
    ).load(db)

print(loaded_speaks.since)
```

--------------------------------

### Load Relationship by Start and End Node IDs

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/database_client.md

Loads a relationship from the database using the start node and end node IDs. It matches properties that are not None.

```python
def load_relationship_with_start_node_id_and_end_node_id(
        relationship: Relationship) -> Optional[Relationship]

```

--------------------------------

### Configure access mode for routed clients

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/high-availability.md

Use access_mode to target specific cluster instances. The reader example uses a string, while the writer example uses the mgclient constant.

```python
from gqlalchemy import Memgraph

# A read-only client, routed to a replica.
reader = Memgraph(host="coordinator-1", port=7687, routing=True, access_mode="READ")
for result in reader.execute_and_fetch("MATCH (n:Person) RETURN count(n) AS count"):
    print(result["count"])
```

```python
import mgclient
from gqlalchemy import Memgraph

writer = Memgraph(
    host="coordinator-1",
    port=7687,
    routing=True,
    access_mode=mgclient.ACCESS_MODE_WRITE,
)
```

--------------------------------

### Get Storage Info

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Retrieves detailed storage metrics from the database instance.

```python
def get_storage_info() -> List[dict]
```

--------------------------------

### MemgraphInstanceBinary.is_running

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/instance_runner.md

Checks if the Memgraph instance started from a binary file is currently running.

```APIDOC
## MemgraphInstanceBinary.is_running

### Description
Check if the Memgraph instance is still running.

### Returns
- `bool`
```

--------------------------------

### Example Usage of to_cypher_queries

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/translators/pyg_translator.md

Demonstrates how to use the `to_cypher_queries` method to generate Cypher queries from a PyG graph and execute them using a Memgraph instance.

```python
>>> memgraph = Memgraph()
pyg_graph = HeteroData(...)
for query in PyGTranslator().to_cypher_queries(pyg_graph):
memgraph.execute(query)
```

--------------------------------

### Get All Constraints from Neo4j

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/neo4j.md

Returns a list of all database constraints, including label and label-property types, from Neo4j.

```python
def get_constraints(
) -> List[Union[Neo4jConstraintExists, Neo4jConstraintUnique]]

```

--------------------------------

### Get or create a node

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/models.md

Retrieves an existing node or creates a new one, returning the node and a creation status flag.

```python
def get_or_create(db: "Database") -> Tuple["Node", bool]
```

--------------------------------

### Import DGL Graph to Memgraph

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/import-python-graphs.md

Converts a DGL heterogeneous graph to Cypher queries for Memgraph. Ensure DGL is installed.

```python
import torch
from dgl.data.utils import load_graphs
from gqlalchemy import Memgraph
from gqlalchemy.transformations.translators.dgl_translator import DGLTranslator

# Load graph from file
graph, _ = load_graphs("dgl_graph.bin")
graph = graph[0]

# Set edge features
graph.edges[("user", "PLUS", "movie")].data["edge_prop1"] = torch.randn(size=(3, 1))
graph.edges[("user", "PLUS", "movie")].data["edge_prop2"] = torch.randn(size=(3, 1))
graph.edges[("user", "MINUS", "movie")].data["edge_prop1"] = torch.randn(size=(1, 1))

translator = DGLTranslator()

for query in list(translator.to_cypher_queries(graph)):
    memgraph.execute(query)
```

--------------------------------

### Get or Create Relationship Method

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/models.md

Retrieves or creates a relationship, returning the object and a boolean indicating if it was newly created.

```python
def get_or_create(db: "Database") -> Tuple["Relationship", bool]
```

--------------------------------

### Import NetworkX Graph into Memgraph

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/import-python-graphs.md

Translates a NetworkX graph into Cypher queries and executes them in Memgraph. Ensure NetworkX is installed and Memgraph is running.

```python
import networkx as nx
from gqlalchemy import Memgraph
from gqlalchemy.transformations.translators.nx_translator import NxTranslator

memgraph = Memgraph()
memgraph.drop_database()

graph = nx.Graph()
graph.add_nodes_from([(1, {"labels": "First"}), (2, {"name": "Kata"}), 3])
graph.add_edges_from([(1, 2, {"type": "EDGE_TYPE", "date": "today"}), (1, 3)])

translator = NxTranslator()

for query in list(translator.to_cypher_queries(graph)):
    memgraph.execute(query)
```

--------------------------------

### Get Memgraph Storage Information

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/manage-database.md

Retrieve detailed storage information about your Memgraph instance, including vertex and edge counts, memory, and disk usage. Requires an active Memgraph instance and GQLAlchemy installation.

```python
from gqlalchemy import Memgraph

db = Memgraph()

storage_info = db.get_storage_info()
for item in storage_info:
    print(item)
```

--------------------------------

### Run GQLAlchemy tests for specific extras with uv

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/installation.md

Executes GQLAlchemy tests for a particular optional extra (e.g., arrow, dgl, docker) using uv. This allows targeted testing of installed functionalities.

```bash
uv run pytest . -k "arrow"
```

```bash
uv run pytest . -k "dgl"
```

```bash
uv run pytest . -k "docker"
```

--------------------------------

### Merge Relationship Between Existing Nodes

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/query-builder.md

This example shows how to merge a relationship between two existing nodes identified by their properties and variables.

```python
from gqlalchemy import Memgraph, match, merge

db = Memgraph()

match().node(labels="Person", name="Leslie", variable="leslie").match().node(
    labels="Person", name="Ron", variable="ron"
).merge().node(variable="leslie").to(relationship_type="FRIENDS_WITH").node(
    variable="ron"
).execute()
```

--------------------------------

### Load Nodes for Relationship Creation

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Load the start and end nodes required to create a relationship. The load() method returns a single result for unique matches.

```python
loaded_streamer = Streamer(id="2").load(db=db)
loaded_language = Language(name="en").load(db=db)
```

--------------------------------

### Create Nodes and Relationships

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/query-builder.md

Demonstrates creating nodes with labels and properties, and establishing relationships between them using the `create()` method.

```python
from gqlalchemy import create, Memgraph

db = Memgraph()
db.drop_database()

create().node(labels="Person", name="Leslie").to(relationship_type="FRIENDS_WITH").node(
    labels="Person", name="Ron"
).execute()

create().node(
    labels="Person", name="Jane", last_name="James", address="street", age=19
).from_(relationship_type="FRIENDS_WITH", since="2023-02-16").node(
    labels="Person", name="John", last_name="James", address="street", age=8
).execute()
```

--------------------------------

### Create and Load Data with On-Disk Property

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/on-disk-storage/on-disk-storage.md

Creates a 'User' node with a large string property stored on disk and demonstrates loading it back. The 'huge_string' is fetched from the SQL database.

```python
my_secret = "I LOVE DUCKS" * 1000
john = User(id=5, huge_string=my_secret).save(db)
john2 = User(id=5).load(db)
print(john2.huge_string)  # prints I LOVE DUCKS, a 1000 times
```

--------------------------------

### Create a Memgraph Graph

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/export-python-graphs.md

This script initializes a Memgraph connection, drops any existing database, and then creates nodes and connections with specified properties. Ensure Memgraph Platform is running before execution.

```python
from gqlalchemy import Memgraph

memgraph = Memgraph()
memgraph.drop_database()

queries = []
queries.append(f"CREATE (m:Node {{id: 1, num: 80, edem: 30, lst: [2, 3, 3, 2]}})")
queries.append(f"CREATE (m:Node {{id: 2, num: 91, edem: 32, lst: [2, 2, 3, 3]}})")
queries.append(
    f"CREATE (m:Node {{id: 3, num: 100, edem: 34, lst: [3, 2, 2, 3, 4, 4]}})"
)
queries.append(f"CREATE (m:Node {{id: 4, num: 12, edem: 34, lst: [2, 2, 2, 3, 5, 5]}})")
queries.append(
    f"MATCH (n:Node {{id: 1}}), (m:Node {{id: 2}}) CREATE (n)-[r:CONNECTION {{edge_id: 1, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1, 0, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 2}}), (m:Node {{id: 3}}) CREATE (n)-[r:CONNECTION {{edge_id: 2, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 3}}), (m:Node {{id: 4}}) CREATE (n)-[r:CONNECTION {{edge_id: 3, edge_num: 99, edge_edem: 12, edge_lst: [1, 0, 1, 0, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 4}}), (m:Node {{id: 1}}) CREATE (n)-[r:CONNECTION {{edge_id: 4, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 1}}), (m:Node {{id: 3}}) CREATE (n)-[r:CONNECTION {{edge_id: 5, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 2}}), (m:Node {{id: 4}}) CREATE (n)-[r:CONNECTION {{edge_id: 6, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1, 0, 0]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 4}}), (m:Node {{id: 2}}) CREATE (n)-[r:CONNECTION {{edge_id: 7, edge_num: 99, edge_edem: 12, edge_lst: [1, 1, 0, 0, 1, 1, 0, 1]}}]->(m)"
)
queries.append(
    f"MATCH (n:Node {{id: 3}}), (m:Node {{id: 1}}) CREATE (n)-[r:CONNECTION {{edge_id: 8, edge_num: 99, edge_edem: 12, edge_lst: [0, 1, 0, 1]}}]->(m)"
)

for query in queries:
    memgraph.execute(query)
```

--------------------------------

### Route a client through a coordinator

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/high-availability.md

Initialize a Memgraph client with routing enabled by setting the host and port to a cluster coordinator.

```python
from gqlalchemy import Memgraph

db = Memgraph(host="coordinator-1", port=7687, routing=True)

# Routed to the main.
db.execute("MERGE (:Person {name: 'Ada'})")

# Also routed to the main (the default access mode serves both reads and writes).
for result in db.execute_and_fetch("MATCH (n:Person) RETURN n.name AS name"):
    print(result["name"])
```

--------------------------------

### AllShortestPath Constructor

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/graph_algorithms/integrated_algorithms.md

Initializes the AllShortestPath algorithm with specified parameters for pathfinding.

```APIDOC
## AllShortestPath

Build a Dijkstra shortest path call for a Cypher query.

### 
```python
class AllShortestPath(IntegratedAlgorithm)
```

### 
```python
def __init__(upper_bound: int = None, condition: str = None, total_weight_var: str = DEFAULT_TOTAL_WEIGHT, weight_property: str = DEFAULT_WEIGHT_PROPERTY) -> None
```

#### Arguments:

- `upper_bound` (int) - Upper bound for path depth.
- `condition` (str) - Filter through nodes and relationships that pass this condition.
- `total_weight_var` (str) - Variable defined as the sum of all weights on path being returned.
- `weight_property` (str) - Property being used as weight.
```

--------------------------------

### Get Transactions

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Retrieves all active transactions in the database.

```python
def get_transactions() -> List[MemgraphTransaction]
```

--------------------------------

### Get Procedures

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Retrieves a list of query procedures from the Memgraph object.

```python
def get_procedures(starts_with: Optional[str] = None,
                   update: bool = False) -> List["QueryModule"]
```

--------------------------------

### Initialize and use GraphImporter

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/graph_importer.md

Demonstrates the basic instantiation and translation process for importing a graph.

```python
>>> importer = GraphImporter("dgl")
graph = DGLGraph(...)
importer.translate(graph)  # queries are inserted in this step
```

--------------------------------

### Initialize DataLoader

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes a DataLoader with a file extension and a file system handler.

```python
def __init__(file_extension: str,
             file_system_handler: FileSystemHandler) -> None
```

--------------------------------

### Initialize and use custom importer

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/loaders/make-a-custom-file-system-importer.md

Instantiate the custom `PyArrowAzureBlobImporter` with necessary parameters and call the `translate()` method to import data. Ensure to provide Azure account credentials.

```python
importer = PyArrowAzureBlobImporter(
    container_name="test"
    file_extension_enum=PyArrowFileTypeEnum.Parquet,
    data_configuration=parsed_yaml,
    account_name="your_account_name",
    account_key="your_account_key",
)

importer.translate(drop_database_on_start=True)
```

--------------------------------

### Connect to Memgraph and SQLite

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/on-disk-storage/on-disk-storage.md

Imports necessary classes and establishes connections to both Memgraph and a local SQLite database for property storage. Ensure Memgraph is running.

```python
from gqlalchemy import Memgraph, SQLitePropertyDatabase, Node, Field
from typing import Optional

graphdb = Memgraph()
SQLitePropertyDatabase('path-to-my-db.db', graphdb)
```

--------------------------------

### Get Storage Mode

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Returns the current storage mode of the Memgraph instance.

```python
def get_storage_mode() -> str
```

--------------------------------

### Create Relationship with Properties (GQLAlchemy)

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/query-builder.md

Use the `create()` method to define nodes and their relationship, including properties. Nodes are created if they don't exist.

```python
from gqlalchemy import create

query = (
    create()
    .node(labels="Person", name="Leslie")
    .to(relationship_type="FRIENDS_WITH", since="2023-02-16")
    .node(labels="Person", name="Ron")
    .execute()
)
```

--------------------------------

### Import MemgraphInstanceBinary

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-binary-instance.md

Import the necessary class for managing Memgraph binary instances.

```python
from gqlalchemy.instance_runner import MemgraphInstanceBinary
```

--------------------------------

### Get All Indexes from Neo4j

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/neo4j.md

Retrieves a list of all database indexes, including label and label-property types, from Neo4j.

```python
def get_indexes() -> List[Neo4jIndex]

```

--------------------------------

### Get Created Constraints

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Retrieve a list of all constraints currently created in the database using the `db.get_constraints()` method.

```python
print(db.get_constraints())
```

--------------------------------

### S3FileSystemHandler Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes a connection to an Amazon S3 bucket for data handling. Requires bucket name and optionally accepts S3 credentials and region.

```python
def __init__(bucket_name: str, **kwargs)

```

--------------------------------

### with_

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/query_builders/declarative_base.md

Chains together parts of a query, piping the results from one to be used as starting points or criteria in the next.

```APIDOC
## with_

### Description
Pipes the result from first part of the query for the further use.

### Method Signature
```python
def with_(
    results: Optional[Union[
        str,
        Tuple[str, str],
        Dict[str, str],
        List[Union[str, Tuple[str, str]]],
        Set[Union[str, Tuple[str, str]]],
    ]] = None
) -> "DeclarativeBase"
```

### Arguments
- `results` - A dictionary mapping variables in the first query with aliases in the second query.

### Returns
A `DeclarativeBase` instance for constructing queries.

### Raises
- `GQLAlchemyResultQueryTypeError` - Raises an error when the provided argument is of wrong type.
- `GQLAlchemyTooLargeTupleInResultQuery` - Raises an error when the given tuple has length larger than 2.

### Example
```python
# Python
match().node(variable='n').with_('n').execute()

# Cypher
MATCH (n) WITH n;
```

--------------------------------

### TableToGraphImporter translate Method

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Performs the translation of table data to graph data. Can optionally drop the database at the start.

```python
def translate(drop_database_on_start: bool = True) -> None
```

--------------------------------

### Initialize Local File System Handler

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes a local file system handler with a specified path for data storage.

```python
def __init__(path: str) -> None
```

--------------------------------

### Connect to Memgraph and execute queries

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/index.md

Connect to a running Memgraph instance, delete all existing nodes and relationships, create a new node with a label and property, and return the result. Ensure Memgraph is running and accessible at the specified host and port.

```python
from gqlalchemy import Memgraph

# Make a connection to the database
memgraph = Memgraph(host='127.0.0.1', port=7687)

# Delete all nodes and relationships
query = "MATCH (n) DETACH DELETE n"

# Execute the query
memgraph.execute(query)

# Create a node with the label FirstNode and message property with the value "Hello, World!"
query = """CREATE (n:FirstNode)
           SET n.message = '{message}'
           RETURN 'Node '  + id(n) + ': ' + n.message AS result""".format(message="Hello, World!")

# Execute the query
results = memgraph.execute_and_fetch(query)

# Print the first member
print(list(results)[0]['result'])
```

--------------------------------

### Start a Pulsar Stream

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/streams/pulsar-streams.md

Call the start_stream() method with the stream object to begin processing data from the Pulsar topic.

```python
db.start_stream(stream)
```

--------------------------------

### Create Various Index Types Programmatically

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Demonstrates the creation of different index types including label, label-property, composite, edge, global edge, and point indexes using `MemgraphIndex` and `create_index`.

```python
label_index = MemgraphIndex("Person")
label_prop_index = MemgraphIndex("Person", "name")
label_composite_index = MemgraphIndex("Person", ("name", "age"))
edge_type_index = MemgraphIndex("REL", None, index_type="EDGE_INDEX_TYPE")
edge_type_property_index = MemgraphIndex("REL", "name", index_type="EDGE_INDEX_TYPE")
global_edge_index = MemgraphIndex(None, "name", index_type="EDGE_GLOBAL_INDEX_TYPE")
point_index = MemgraphIndex("Person", "year", index_type="POINT_INDEX_TYPE")

memgraph.create_index(label_index)
memgraph.create_index(label_prop_index)
memgraph.create_index(label_composite_index)
memgraph.create_index(edge_type_index)
memgraph.create_index(edge_type_property_index)
memgraph.create_index(global_edge_index)
memgraph.create_index(point_index)
```

--------------------------------

### Create Relationship Between Existing Nodes (GQLAlchemy)

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/query-builder.md

First match existing nodes using `match()` and then create a relationship between them using `create()`. Requires `match` and `create` imports.

```python
from gqlalchemy import create, match

query = (
    match()
    .node(labels="Person", name="Leslie", variable="leslie")
    .match()
    .node(labels="Person", name="Ron", variable="ron")
    create()
    .node(variable="leslie")
    .to(relationship_type="FRIENDS_WITH")
    .node(variable="ron")
    .execute()
)
```

--------------------------------

### Get a single result

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/query_builders/declarative_base.md

Use `get_single` to retrieve a single result from the query based on a specified variable name.

```python
def get_single(retrieve: str) -> Any

```

--------------------------------

### Import necessary classes from GQLAlchemy

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-docker-instance.md

Import the DockerImage and MemgraphInstanceDocker classes for managing Memgraph Docker instances.

```python
from gqlalchemy.instance_runner import (
    DockerImage,
    MemgraphInstanceDocker
)
```

--------------------------------

### Get all triggers from the database

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/triggers/triggers.md

Use the get_triggers() method on the database object to retrieve a list of all currently active triggers.

```python
triggers = db.get_triggers()
print(triggers)
```

--------------------------------

### Connect to Neo4j Database

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Instantiate a Neo4j database connection using provided credentials.

```python
db = Neo4j(host="localhost", port="7687", username="neo4j", password="test")
```

--------------------------------

### Import TF-GNN Graph to Memgraph

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/translators/import-python-graphs.md

Converts a TF-GNN GraphTensor to Cypher queries for Memgraph. Requires TensorFlow GNN installation.

```python
import os
os.environ["TF_USE_LEGACY_KERAS"] = "1"  # Required for TensorFlow 2.16+

import tensorflow as tf
import tensorflow_gnn as tfgnn
from gqlalchemy import Memgraph
from gqlalchemy.transformations.translators.tfgnn_translator import TFGNNTranslator

memgraph = Memgraph()
memgraph.drop_database()

# Create a TF-GNN GraphTensor
graph_tensor = tfgnn.GraphTensor.from_pieces(
    node_sets={
        "user": tfgnn.NodeSet.from_fields(
            sizes=[3],
            features={
                "name": tf.constant(["Alice", "Bob", "Charlie"]),
                "age": tf.constant([25, 30, 35], dtype=tf.int64),
            }
        ),
        "movie": tfgnn.NodeSet.from_fields(
            sizes=[2],
            features={
                "title": tf.constant(["Inception", "Matrix"]),
                "rating": tf.constant([8.8, 8.7], dtype=tf.float32),
            }
        ),
    },
    edge_sets={
        "LIKES": tfgnn.EdgeSet.from_fields(
            sizes=[3],
            adjacency=tfgnn.Adjacency.from_indices(
                source=("user", tf.constant([0, 0, 1])),
                target=("movie", tf.constant([0, 1, 0])),
            ),
            features={
                "score": tf.constant([5, 4, 5], dtype=tf.int64),
            }
        ),
    },
)

translator = TFGNNTranslator()

for query in translator.to_cypher_queries(graph_tensor):
    memgraph.execute(query)
```

--------------------------------

### Configure Memgraph Instance with Flags

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/instance-runner/memgraph-binary-instance.md

Pass configuration flags to the Memgraph instance during initialization using a dictionary.

```python
config={"--log-level": "TRACE"}
memgraph_instance = MemgraphInstanceBinary(config=config)
```

--------------------------------

### load_relationship

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/database_client.md

Loads a relationship from the database. It can find relationships by internal ID, or by matching start node, end node, and properties.

```APIDOC
## load_relationship

### Description
Returns a relationship loaded from the database.
If the relationship._id is not None, it fetches the relationship from
the database that has the same internal id.
Otherwise it returns the relationship whose relationship._start_node_id
and relationship._end_node_id and all relationship properties that
are not None match the relationship in the database.
If there is no relationship like that in database, or if there are
multiple relationships like that in database, throws GQLAlchemyError.

### Signature
```python
@abstractmethod
def load_relationship(relationship: Relationship) -> Optional[Relationship]
```

### Parameters
* **relationship** (Relationship) - The Relationship object used as a template for loading.

### Returns
* Optional[Relationship] - The loaded Relationship object, or None if no matching relationship is found.
```

--------------------------------

### AzureBlobFileSystemHandler Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes a connection to an Azure Blob container. Requires container name and accepts Azure account credentials or a SAS token.

```python
def __init__(container_name: str, **kwargs) -> None

```

--------------------------------

### FeatherAzureBlobFileSystemImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the FeatherAzureBlobFileSystemImporter for reading Feather/IPC/Arrow files from Azure Blob storage. Requires container name and data configuration.

```python
class FeatherAzureBlobFileSystemImporter(PyArrowAzureBlobImporter)
def __init__(container_name,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None,
             **kwargs) -> None
```

--------------------------------

### Get Local File Path

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Retrieves the file path within the local file system for a given collection name.

```python
def get_path(collection_name: str) -> str
```

--------------------------------

### OnDiskPropertyDatabase Methods

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/disk_storage.md

Abstract methods for saving, loading, and deleting node and relationship properties from disk, as well as dropping the entire database.

```APIDOC
## OnDiskPropertyDatabase

An abstract class for implementing on-disk storage features with specific databases.

### Methods

#### save_node_property

```python
def save_node_property(node_id: int, property_name: str, property_value: str) -> None
```

Saves a node property to an on disk database.

#### load_node_property

```python
def load_node_property(node_id: int, property_name: str, property_value: str) -> Optional[str]
```

Loads a node property from an on disk database.

#### delete_node_property

```python
def delete_node_property(node_id: int, property_name: str, property_value: str) -> None
```

Deletes a node property from an on disk database.

#### save_relationship_property

```python
def save_relationship_property(relationship_id: int, property_name: str, property_value: str) -> None
```

Saves a relationship property to an on disk database.

#### load_relationship_property

```python
def load_relationship_property(relationship_id: int, property_name: str, property_value: str) -> Optional[str]
```

Loads a relationship property from an on disk database.

#### delete_relationship_property

```python
def delete_relationship_property(node_id: int, property_name: str, property_value: str) -> None
```

Deletes a node property from an on disk database.

#### drop_database

```python
def drop_database() -> None
```

Deletes all entries from the on disk database.
```

--------------------------------

### Merge Relationship

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Merge a relationship by attempting to load it first. If the relationship does not exist between the specified start and end nodes, it is created and saved.

```python
try:
    speaks = Speaks(_start_node_id=streamer._id, _end_node_id=language._id).load(db)
except:
    print("Creating new Speaks relationship in the database.")
    speaks = Speaks(
        _start_node_id=streamer._id,
        _end_node_id=language._id,
        since="2023-02-20",
    ).save(db)
```

--------------------------------

### Get Created Indexes

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

After defining indexes in your model classes, you can retrieve a list of all created indexes in the database using the `get_indexes()` method.

```python
print(db.get_indexes())
```

--------------------------------

### Initialize Azure Blob File System Importer

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/loaders/import-table-data-to-graph-database.md

Instantiate the ParquetAzureBlobFileSystemImporter to connect to Azure Blob storage for data import. Ensure you provide the container name, data configuration, account name, and account key.

```python
importer = ParquetAzureBlobFileSystemImporter(
    container_name="test",
    data_configuration=parsed_yaml,
    account_name="your_account_name",
    account_key="your_account_key",
)
```

--------------------------------

### Get QueryModule Arguments for Call

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/graph_algorithms/query_modules.md

Retrieves argument values formatted for the QueryBuilder call() method. Raises KeyError if any arguments are not set.

```python
def get_arguments_for_call() -> str

```

--------------------------------

### Import GQLAlchemy Classes

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Import necessary classes from the gqlalchemy library for OGM operations.

```python
from gqlalchemy import Memgraph, Node, Relationship
```

--------------------------------

### PyArrowLocalFileSystemImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the PyArrowLocalFileSystemImporter for reading data from the local file system. Requires the path to the directory, file extension enum, and data configuration.

```python
def __init__(path: str,
             file_extension_enum: PyArrowFileTypeEnum,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None) -> None
```

--------------------------------

### load_relationship_with_start_node_id_and_end_node_id

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/database_client.md

Loads a relationship from the database using the start node and end node IDs. It matches relationships where all non-None properties of the relationship match.

```APIDOC
## load_relationship_with_start_node_id_and_end_node_id

### Description
Loads a relationship from the database using start node and end node id for which all properties of the relationship that are not None match.

### Signature
```python
def load_relationship_with_start_node_id_and_end_node_id(relationship: Relationship) -> Optional[Relationship]
```
```

--------------------------------

### Retrieve Database Constraints

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Method to list all existing database constraints.

```python
def get_constraints(
) -> List[Union[MemgraphConstraintExists, MemgraphConstraintUnique]]
```

--------------------------------

### Connection Management

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/memgraph.md

Method to establish a new connection to the database.

```python
def new_connection() -> Connection
```

--------------------------------

### FeatherLocalFileSystemImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the FeatherLocalFileSystemImporter for reading Feather/IPC/Arrow files from the local file system. Requires the file path and data configuration.

```python
class FeatherLocalFileSystemImporter(PyArrowLocalFileSystemImporter)
def __init__(path: str,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None) -> None
```

--------------------------------

### DeclarativeBase create method

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/query_builders/declarative_base.md

Create nodes and relationships in a graph. Use this to add new data to the database.

```python
def create() -> "DeclarativeBase":
```

```python
create().node(labels='Person', variable='p').return_(results='p').execute()
```

```cypher
CREATE (p:Person) RETURN p;
```

--------------------------------

### WeightedShortestPath Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/graph_algorithms/integrated_algorithms.md

Initializes a Weighted Shortest Path algorithm instance. Specify upper bound, filter condition, total weight variable, and the property to use as weight.

```python
def __init__(upper_bound: int = None,
             condition: str = None,
             total_weight_var: str = DEFAULT_TOTAL_WEIGHT,
             weight_property: str = DEFAULT_WEIGHT_PROPERTY) -> None
```

--------------------------------

### Delete Statistics for Specific Labels

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/manage-database.md

Delete graph statistics for only specific labels. This allows for granular control over which statistics are removed. Ensure GQLAlchemy is installed and Memgraph is running.

```python
from gqlalchemy import Memgraph

db = Memgraph()

deleted = db.delete_graph_statistics(labels=["Person"])
for item in deleted:
    print(item)
```

--------------------------------

### Save Initial Nodes

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/ogm.md

Save initial node instances to the database. This is a prerequisite for loading them later or creating relationships between them.

```python
jane = Streamer(id="2", username="janedoe", followers=111).save(db)
language = Language(name="en").save(db)
```

--------------------------------

### Analyze Specific Graph Labels

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/how-to-guides/manage-database.md

Analyze statistics for only specific labels within the graph. This is useful for targeted performance tuning. Ensure GQLAlchemy is installed and Memgraph is running.

```python
from gqlalchemy import Memgraph

db = Memgraph()

results = db.analyze_graph(labels=["Person", "City"])
for result in results:
    print(result)
```

--------------------------------

### Get Node Properties from PyG Graph

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/translators/pyg_translator.md

Extracts properties for a specific node from a heterogeneous PyG graph using its label and ID. Requires a reference to the PyG graph.

```python
@classmethod
def get_node_properties(cls, graph, node_label: str, node_id: int)
```

--------------------------------

### TableToGraphImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the TableToGraphImporter with a DataLoader, data configuration, and an optional Memgraph connection.

```python
def __init__(data_loader: DataLoader,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None) -> None
```

--------------------------------

### ORCLocalFileSystemImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the ORCLocalFileSystemImporter for reading ORC files from the local file system. Requires the file path and data configuration.

```python
class ORCLocalFileSystemImporter(PyArrowLocalFileSystemImporter)
def __init__(path: str,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None) -> None
```

--------------------------------

### ParquetAzureBlobFileSystemImporter Initialization

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/transformations/importing/loaders.md

Initializes the ParquetAzureBlobFileSystemImporter for reading Parquet files from an Azure Blob container. Requires the container name and data configuration.

```python
def __init__(container_name: str,
             data_configuration: Dict[str, Any],
             memgraph: Optional[Memgraph] = None,
             **kwargs) -> None
```

--------------------------------

### Load Relationship from Neo4j

Source: https://github.com/memgraph/gqlalchemy/blob/main/docs/reference/gqlalchemy/vendors/neo4j.md

Loads a relationship from the Neo4j database. Matches by internal ID, or by start node, end node, and properties. Throws GQLAlchemyError if no unique match is found.

```python
def load_relationship(relationship: Relationship) -> Optional[Relationship]

```
Tokens:
Raw