Async API Documentation¶

Core¶

`AsyncSemiStructuredNode`¶

class neomodel.contrib.AsyncSemiStructuredNode(*args: Any, **kwargs: Any)¶

A base class allowing properties to be stored on a node that aren’t specified in its definition. Conflicting properties are signaled with the DeflateConflict exception:

class Person(AsyncSemiStructuredNode):
    name = StringProperty()
    age = IntegerProperty()

    def hello(self):
        print("Hi my names " + self.name)

tim = await Person(name='Tim', age=8, weight=11).save()
tim.hello = "Hi"
await tim.save() # DeflateConflict

Relationships¶

class neomodel.async_.relationship.AsyncStructuredRel(**kwargs: dict[str, Any])¶

Bases: StructuredRelBase

Base class for relationship objects

async end_node() → Any¶

Get end node

Returns:: StructuredNode

classmethod inflate(graph_entity: Relationship) → AsyncStructuredRel¶: Inflate a neo4j_driver relationship object to a neomodel object :param graph_entity: Relationship :return: StructuredRel

save() → AsyncStructuredRel¶

Save the relationship

Returns:: self

async start_node() → Any¶

Get start node

Returns:: StructuredNode

class neomodel.async_.relationship.StructuredRelBase(**kwargs: dict[str, Any])¶: Bases: AsyncPropertyManager

class neomodel.async_.relationship_manager.AsyncRelationshipManager(source: Any, key: str, definition: dict)¶

Bases: object

Base class for all relationships managed through neomodel.

I.e the ‘friends’ object in user.friends.all()

async all() → list¶

Return all related nodes.

Returns:: list

all_relationships(node: AsyncStructuredNode) → list[AsyncStructuredRel]¶

Retrieve all relationship objects between self and node.

Parameters:: node
Returns:: [StructuredRel]

async check_cardinality(node: AsyncStructuredNode) → None¶

Check whether a new connection to a node would violate the cardinality of the relationship.

Parameters:: node – The node that is being connected.
Type:: AsyncStructuredNode
Raises:: AttemptedCardinalityViolation

async check_mutual_exclusion() → None¶

Check whether connecting this relationship would violate a mutual exclusion group. Relationships sharing the same exclusion_group on the source node are mutually exclusive: at most one of them may hold any connection at a time (this is orthogonal to each relationship’s own cardinality).

Raises:: MutualExclusionViolation

connect(node: AsyncStructuredNode, properties: dict[str, Any] | None = None) → AsyncStructuredRel | None¶

Connect a node

Parameters:

node
properties – for the new relationship

Type:

dict

Returns:

disconnect(node: AsyncStructuredNode) → None¶

Disconnect a node

Parameters:: node
Returns:

disconnect_all() → None¶

Disconnect all nodes

Returns:

exclude(*args: Any, **kwargs: dict) → AsyncBaseSet¶

Exclude nodes that match the provided properties.

Parameters:

args – a Q object
kwargs – same syntax as NodeSet.filter()

Returns:

NodeSet

filter(*args: Any, **kwargs: dict) → AsyncBaseSet¶

Retrieve related nodes matching the provided properties.

Parameters:

args – a Q object
kwargs – same syntax as NodeSet.filter()

Returns:

NodeSet

async get(**kwargs: Any)¶

Retrieve a related node with the matching node properties.

Parameters:: kwargs – same syntax as NodeSet.filter()
Returns:: node

async get_or_none(**kwargs: dict)¶

Retrieve a related node with the matching node properties or return None.

Parameters:: kwargs – same syntax as NodeSet.filter()
Returns:: node

async is_connected(node: AsyncStructuredNode) → bool¶: Check if a node is connected with this relationship type :param node: :return: bool

match(**kwargs: Any) → AsyncNodeSet¶

Return set of nodes whose relationship properties match supplied args

Parameters:: kwargs – same syntax as NodeSet.filter()
Returns:: NodeSet

order_by(*props: Any) → AsyncBaseSet¶

Order related nodes by specified properties

Parameters:: props
Returns:: NodeSet

reconnect(old_node: AsyncStructuredNode, new_node: AsyncStructuredNode) → None¶

Disconnect old_node and connect new_node copying over any properties on the original relationship.

Useful for preventing cardinality violations

Parameters:

old_node
new_node

Returns:

None

relationship(node: AsyncStructuredNode) → AsyncStructuredRel | None¶

Retrieve the relationship object for this first relationship between self and node.

Parameters:: node
Returns:: StructuredRel

replace(node: AsyncStructuredNode, properties: dict[str, Any] | None = None) → None¶

Disconnect all existing nodes and connect the supplied node

Parameters:

node
properties – for the new relationship

Type:

dict

Returns:

async single() → AsyncStructuredNode | None¶

Get a single related node or none.

Returns:: StructuredNode

class neomodel.async_.relationship_manager.AsyncZeroOrMore(source: Any, key: str, definition: dict)¶

Bases: AsyncRelationshipManager

A relationship of zero or more nodes (the default)

neomodel.async_.relationship_manager.deflate_relationship_properties(relationship: AsyncRelationshipManager, rel_props: dict[str, Any], query_params: dict[str, Any]) → dict[str, str]¶

Deflate relationship properties and prepare them for Cypher query.

Parameters:

relationship – The relationship manager containing the model
rel_props – Dictionary of relationship properties to deflate
query_params – Query parameters dict to add deflated values to

Returns:

Dictionary mapping property names to parameter placeholders (e.g. {‘since’: ‘$since’})

neomodel.async_.relationship_manager.validate_relationship(relationship: Any, rel_props: Any) → None¶

Validate relationship manager.

Parameters:

relationship – The relationship manager to validate

Raises:

TypeError – If relationship is not an AsyncRelationshipManager
ValueError – If relationship source is invalid or relation_type is missing
RuntimeError – If relationship source element_id is None

class neomodel.async_.cardinality.AsyncOne(source: Any, key: str, definition: dict)¶

Bases: AsyncRelationshipManager

A relationship to a single node

async all() → list[AsyncStructuredNode]¶

Return single node in an array

Returns:: [node]

async check_cardinality(node: AsyncStructuredNode) → None¶

Check whether a new connection to a node would violate the cardinality of the relationship.

Parameters:: node – The node that is being connected.
Type:: AsyncStructuredNode
Raises:: AttemptedCardinalityViolation

async connect(node: AsyncStructuredNode, properties: dict[str, Any] | None = None) → AsyncStructuredRel¶

Connect a node

Parameters:

node
properties – relationship properties

Returns:

True / rel instance

async disconnect(node: AsyncStructuredNode) → None¶

Disconnect a node

Parameters:: node
Returns:

async disconnect_all() → None¶

Disconnect all nodes

Returns:

async single() → AsyncStructuredNode¶

Return the associated node.

Returns:: node

class neomodel.async_.cardinality.AsyncOneOrMore(source: Any, key: str, definition: dict)¶

Bases: AsyncRelationshipManager

A relationship to zero or more nodes.

async all() → list[AsyncStructuredNode]¶

Returns all related nodes.

Returns:: [node1, node2…]

async disconnect(node: AsyncStructuredNode) → None¶: Disconnect node :param node: :return:

async disconnect_all() → None¶

Disconnect all nodes

Returns:

async single() → AsyncStructuredNode¶

Fetch one of the related nodes

Returns:: Node

class neomodel.async_.cardinality.AsyncZeroOrMore(source: Any, key: str, definition: dict)¶

Bases: AsyncRelationshipManager

A relationship of zero or more nodes (the default)

class neomodel.async_.cardinality.AsyncZeroOrOne(source: Any, key: str, definition: dict)¶

Bases: AsyncRelationshipManager

A relationship to zero or one node.

async all() → list[AsyncStructuredNode]¶

Return all related nodes.

Returns:: list

async check_cardinality(node: AsyncStructuredNode) → None¶

Check whether a new connection to a node would violate the cardinality of the relationship.

Parameters:: node – The node that is being connected.
Type:: AsyncStructuredNode
Raises:: AttemptedCardinalityViolation

async connect(node: AsyncStructuredNode, properties: dict[str, Any] | None = None) → AsyncStructuredRel¶

Connect to a node.

Parameters:

node
properties – relationship properties

Type:

StructuredNode

Type:

dict

Returns:

True / rel instance

async single() → AsyncStructuredNode | None¶

Return the associated node.

Returns:: node

Property Manager¶

class neomodel.async_.property_manager.AsyncPropertyManager(**kwargs: dict[str, Any])¶

Bases: object

Common methods for handling properties on node and relationship objects.

classmethod deflate(properties: Any, obj: Any = None, skip_empty: bool = False) → dict[str, Any]¶

Deflate the properties of a PropertyManager subclass (a user-defined StructuredNode or StructuredRel) so that it can be put into a neo4j.graph.Entity (a neo4j.graph.Node or neo4j.graph.Relationship) for storage. properties can be constructed manually, or fetched from a PropertyManager subclass using __properties__.

Includes mapping from python class attribute name -> database property name (see Property.db_property).

Ignores any properties that are not defined as python attributes in the class definition.

classmethod inflate(graph_entity: Node | Relationship) → Any¶: Inflate the properties of a graph entity (a neo4j.graph.Node or neo4j.graph.Relationship) into an instance of cls. Includes mapping from database property name (see Property.db_property) -> python class attribute name. Ignores any properties that are not defined as python attributes in the class definition.

Paths¶

class neomodel.async_.path.AsyncNeomodelPath(a_neopath: Path)¶

Bases: object

Represents paths within neomodel.

This object is instantiated when you include whole paths in your cypher_query() result sets and turn resolve_objects to True.

That is, any query of the form:

MATCH p=(:SOME_NODE_LABELS)-[:SOME_REL_LABELS]-(:SOME_OTHER_NODE_LABELS) return p

NeomodelPath are simple objects that reference their nodes and relationships, each of which is already resolved to their neomodel objects if such mapping is possible.

Parameters:

nodes (list[StructuredNode]) – Neomodel nodes appearing in the path in order of appearance.
relationships (list[StructuredRel]) – Neomodel relationships appearing in the path in order of appearance.

property end_node: AsyncStructuredNode¶: The last StructuredNode in this path.

property start_node: AsyncStructuredNode¶: The first StructuredNode in this path.

Match¶

class neomodel.async_.match.AsyncBaseSet¶

Base class for all node sets.

Contains common python magic methods, __len__, __contains__ etc

async all(lazy: bool = False) → list[T]¶: Return all nodes belonging to the set :param lazy: False by default, specify True to get nodes with id only without the parameters. :return: list of nodes :rtype: list

async check_bool() → bool¶: Override for __bool__ dunder method. :return: True if the set contains any nodes, False otherwise :rtype: bool

async check_contains(obj: AsyncStructuredNode | Any) → bool¶

async check_nonzero() → bool¶: Override for __bool__ dunder method. :return: True if the set contains any node, False otherwise :rtype: bool

async get_item(key: int | slice) → Self | T¶

async get_len() → int¶

query_cls¶: alias of AsyncQueryBuilder

relations_to_fetch: list[Path]¶

source: Any¶

source_class: type[T]¶

class neomodel.async_.match.AsyncNodeSet(source: Any)¶

A class representing as set of nodes matching common query parameters

annotate(*vars: tuple, **aliased_vars: tuple) → Self¶: Annotate node set results with extra variables.

async bulk_create(*props: Any, **kwargs: Any) → list[T]¶

Create multiple nodes of this set’s class in a single round-trip.

Each positional argument is a dict of properties for one node. This is the batch counterpart to StructuredNode.save() (which creates one node); it replaces the deprecated MyNode.create(...) classmethod.

Parameters:

props – one dict of properties per node to create
lazy – if True, return nodes with element_id only

Returns:

list of created nodes, in the order supplied

async bulk_create_or_update(*props: Any, **kwargs: Any) → list[T]¶

Create or update multiple nodes in a single MERGE round-trip.

Replaces the deprecated MyNode.create_or_update(...) classmethod. See bulk_create for the props/lazy/merge_by arguments.

Returns:: list of created/updated nodes, in the order supplied

async bulk_get_or_create(*props: Any, **kwargs: Any) → list[T]¶

Get or create multiple nodes in a single MERGE round-trip.

Replaces the deprecated MyNode.get_or_create(...) classmethod. See bulk_create for the props/lazy/merge_by arguments.

Returns:: list of fetched/created nodes, in the order supplied

async bulk_save(nodes: list[T]) → list[T]¶

Persist a list of node instances of this set’s class in bulk.

Convenience mirror of StructuredNode.bulk_save(...) so every batch operation is reachable from MyNode.nodes.

Parameters:: nodes – node instances to save
Returns:: the same instances, in order

dont_match: dict¶

exclude(*args: Any, **kwargs: Any) → Self¶

Exclude nodes from the NodeSet via filters.

Parameters:: kwargs – filter parameters see syntax for the filter method
Returns:: self

filter(*args: Any, **kwargs: Any) → Self¶

Apply filters to the existing nodes in the set.

Parameters:

args –
a Q object

e.g .filter(Q(salary__lt=10000) | Q(salary__gt=20000)).
kwargs –
filter parameters

Filters mimic Django’s syntax with the double ‘__’ to separate field and operators.

e.g .filter(salary__gt=20000) results in salary > 20000.

The following operators are available:
- ’lt’: less than
- ’gt’: greater than
- ’lte’: less than or equal to
- ’gte’: greater than or equal to
- ’ne’: not equal to
- ’in’: matches one of list (or tuple)
- ’isnull’: is null
- ’regex’: matches supplied regex (neo4j regex format)
- ’exact’: exactly match string (just ‘=’)
- ’iexact’: case insensitive match string
- ’contains’: contains string
- ’icontains’: case insensitive contains
- ’startswith’: string starts with
- ’istartswith’: case insensitive string starts with
- ’endswith’: string ends with
- ’iendswith’: case insensitive string ends with
- ’includes’: ArrayProperty contains the given element
- ’includes_all’: ArrayProperty contains all the given elements
- ’includes_any’: ArrayProperty contains any of the given elements

Returns:

self

filters: list¶

async first(**kwargs: Any) → T¶

Retrieve the first node from the set matching supplied parameters

Parameters:: kwargs – same syntax as filter()
Returns:: node

async first_or_none(**kwargs: Any) → T | None¶

Retrieve the first node from the set matching supplied parameters or return none

Parameters:: kwargs – same syntax as filter()
Returns:: node or none

fulltext_query: FulltextFilter | None¶

async get(lazy: bool = False, **kwargs: Any) → T¶: Retrieve one node from the set matching supplied parameters :param lazy: False by default, specify True to get nodes with id only without the parameters. :param kwargs: same syntax as filter() :return: node

async get_or_none(**kwargs: Any) → T | None¶

Retrieve a node from the set matching supplied parameters or return none

Parameters:: kwargs – same syntax as filter()
Returns:: node or none

intermediate_transform(vars: dict[str, Transformation], distinct: bool = False, ordering: list | None = None) → Self¶

must_match: dict¶

order_by(*props: Any) → Self¶: Order by properties. Prepend with minus to do descending. Pass None to remove ordering.

order_by_elements: list¶

relations_to_fetch: list[Path]¶

async resolve_subgraph() → list¶

Convert every result contained in this node set to a subgraph.

By default, we receive results from neomodel as a list of nodes without the hierarchy. This method tries to rebuild this hierarchy without overriding anything in the node, that’s why we use a dedicated property to store node’s relations.

async subquery(nodeset: Self, return_set: list[str], initial_context: list[str | NodeNameResolver | RelationNameResolver | RawCypher] | None = None) → Self¶

Add a subquery to this node set.

A subquery is a regular cypher query but executed within the context of a CALL statement. Such query will generally fetch additional variables which must be declared inside return_set variable in order to be included in the final RETURN statement.

traverse(*paths: tuple[str, ...], **aliased_paths: dict) → Self¶: Specify a set of paths to traverse.

unique_variables(*paths: str) → Self¶: Generate unique variable names for the given paths.

vector_query: VectorFilter | None¶

class neomodel.async_.match.AsyncTraversal(source: Any, name: str, definition: dict)¶

Models a traversal from a node to another.

Parameters:

source (A StructuredNode subclass, an instance of such, a NodeSet instance or a Traversal instance.) – Starting of the traversal.
name (str) – A name for the traversal.
definition (dict) – A relationship definition that most certainly deserves a documentation here.

definition: dict¶

filters: list¶

match(**kwargs: dict[str, Any]) → AsyncNodeSet¶

Traverse relationships with properties matching the given parameters.

e.g: .match(price__lt=10)

Parameters:: kwargs – see NodeSet.filter() for syntax
Returns:: NodeSet wrapping this traversal

name: str¶

source: Any¶

source_class: Any¶

target_class: Any¶

Async API Documentation¶

Core¶

AsyncSemiStructuredNode¶

Relationships¶

Property Manager¶

Paths¶

Match¶

`AsyncSemiStructuredNode`¶