rushdb 2.2.0__tar.gz → 2.3.0__tar.gz

{rushdb-2.2.0 → rushdb-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rushdb
-Version: 2.2.0
+Version: 2.3.0
 Summary: RushDB Python SDK — memory layer for AI agents and modern apps
 Project-URL: Homepage, https://github.com/rush-db/rushdb-python
 Project-URL: Repository, https://github.com/rush-db/rushdb-python
@@ -138,7 +138,17 @@ authored_posts = db.records.find({
 # Manage relationships explicitly
 user = db.records.find_uniq({'labels': ['USER'], 'where': {'name': 'Alice'}})
 company = db.records.find_uniq({'labels': ['COMPANY'], 'where': {'name': 'Acme Corp'}})
-user.attach(target=company, options={'type': 'WORKS_AT', 'direction': 'out'})
+user.attach(
+    target=company,
+    options={'type': 'WORKS_AT', 'direction': 'out', 'properties': {'source': 'profile'}},
+)
+
+# Relationship search: where filters edge type/properties, source/target filter endpoint records
+relationships = db.relationships.find({
+    'source': {'labels': ['USER'], 'where': {'name': 'Alice'}},
+    'target': {'labels': ['COMPANY']},
+    'where': {'type': 'WORKS_AT', 'source': 'profile'},
+})
 ```
 
 ---

{rushdb-2.2.0 → rushdb-2.3.0}/README.md

@@ -113,7 +113,17 @@ authored_posts = db.records.find({
 # Manage relationships explicitly
 user = db.records.find_uniq({'labels': ['USER'], 'where': {'name': 'Alice'}})
 company = db.records.find_uniq({'labels': ['COMPANY'], 'where': {'name': 'Acme Corp'}})
-user.attach(target=company, options={'type': 'WORKS_AT', 'direction': 'out'})
+user.attach(
+    target=company,
+    options={'type': 'WORKS_AT', 'direction': 'out', 'properties': {'source': 'profile'}},
+)
+
+# Relationship search: where filters edge type/properties, source/target filter endpoint records
+relationships = db.relationships.find({
+    'source': {'labels': ['USER'], 'where': {'name': 'Alice'}},
+    'target': {'labels': ['COMPANY']},
+    'where': {'type': 'WORKS_AT', 'source': 'profile'},
+})
 ```
 
 ---

{rushdb-2.2.0 → rushdb-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rushdb"
-version = "2.2.0"
+version = "2.3.0"
 description = "RushDB Python SDK — memory layer for AI agents and modern apps"
 authors = [
     {name = "RushDB Team", email = "hi@rushdb.com"}
@@ -81,8 +81,6 @@ line-length = 120
 
 [tool.isort]
 profile = "black"
-multi_line_output = 3
-line_length = 120
 
 [dependency-groups]
 dev = [

{rushdb-2.2.0 → rushdb-2.3.0}/src/rushdb/__init__.py

@@ -13,8 +13,18 @@ from .common import NonUniqueResultError, RushDBError
 from .models.api_response import ApiResponse
 from .models.property import Property
 from .models.record import Record, RecordTarget, RelationTarget
-from .models.relationship import RelationshipDetachOptions, RelationshipOptions
+from .models.relationship import (
+    Relationship,
+    RelationshipDetachOptions,
+    RelationshipDirection,
+    RelationshipOptions,
+)
 from .models.result import RecordSearchResult, SearchResult
+from .models.search_query import (
+    RelationshipEndpointQuery,
+    RelationshipSearchQuery,
+    SearchQuery,
+)
 from .models.transaction import Transaction
 
 __all__ = [
@@ -29,8 +39,13 @@ __all__ = [
     "SearchResult",
     "Transaction",
     "Property",
+    "Relationship",
+    "RelationshipDirection",
     "RelationshipOptions",
     "RelationshipDetachOptions",
+    "SearchQuery",
+    "RelationshipEndpointQuery",
+    "RelationshipSearchQuery",
     "QueryAPI",
     "RelationsAPI",
     "RelationshipPatternsAPI",

{rushdb-2.2.0 → rushdb-2.3.0}/src/rushdb/api/records.py

@@ -446,6 +446,17 @@ class RecordsAPI(BaseAPI):
             >>>
             >>> # Attach using Record objects
             >>> response = records_api.attach(source_record, target_records)
+            >>>
+            >>> # Attach with a typed relationship carrying edge properties
+            >>> response = records_api.attach(
+            ...     movie,
+            ...     actor,
+            ...     options={
+            ...         "type": "STARS_IN",
+            ...         "direction": "out",
+            ...         "properties": {"role": "lead", "billing": 1},
+            ...     },
+            ... )
         """
         headers = Transaction._build_transaction_header(transaction)
 

{rushdb-2.2.0 → rushdb-2.3.0}/src/rushdb/api/relationships.py

@@ -1,9 +1,9 @@
 import typing
-from typing import TYPE_CHECKING, List, Optional, TypedDict, Union
-from urllib.parse import urlencode
+from typing import TYPE_CHECKING, Optional, TypedDict, Union
 
 from ..models.relationship import Relationship
-from ..models.search_query import SearchQuery
+from ..models.result import SearchResult
+from ..models.search_query import RelationshipSearchQuery
 from ..models.transaction import Transaction
 from .base import BaseAPI
 from .relationship_patterns import RelationshipPatternsAPI
@@ -47,21 +47,19 @@ class RelationsAPI(BaseAPI):
     Attributes:
         client: The underlying RushDB client instance for making HTTP requests.
 
-    Note:
-        This API currently contains async methods. Ensure you're using it in an
-        async context or consider updating to sync methods if needed.
-
     Example:
         >>> from rushdb import RushDB
         >>> client = RushDB(api_key="your_api_key")
         >>> relations_api = client.relationships
         >>>
         >>> # Find all relationships
-        >>> relationships = await relations_api.find()
+        >>> relationships = relations_api.find()
+        >>>
+        >>> # Filter by edge type and properties
+        >>> leads = relations_api.find({"where": {"type": "STARS_IN", "role": "lead"}})
         >>>
         >>> # Find relationships with pagination
-        >>> pagination = {"limit": 50, "skip": 0}
-        >>> page_1 = await relations_api.find(pagination=pagination)
+        >>> page_1 = relations_api.find(pagination={"limit": 50, "skip": 0})
     """
 
     def __init__(self, client: "RushDB"):
@@ -70,40 +68,57 @@ class RelationsAPI(BaseAPI):
 
     def find(
         self,
-        search_query: Optional[SearchQuery] = None,
+        search_query: Optional[RelationshipSearchQuery] = None,
         pagination: Optional[PaginationParams] = None,
         transaction: Optional[Union[Transaction, str]] = None,
-    ) -> List[Relationship]:
+    ) -> SearchResult[Relationship]:
         """Search for and retrieve relationships matching the specified criteria.
 
         Args:
-            search_query: The search criteria to filter relationships.
+            search_query: Relationship-edge criteria. ``where`` filters the edge —
+                ``type`` maps to the relationship type, ``direction`` constrains
+                direction, and every other key matches a user-defined edge property
+                (full operator set: ``$gte``, ``$contains``, ``$in``, ``$exists``,
+                logical grouping, ...). Use top-level ``source`` and ``target``
+                (``{"labels": [...], "where": {...}}``) to filter endpoint records.
+                ``limit``/``skip`` inside the query control pagination.
                 If None, returns all relationships (subject to pagination limits).
-            pagination: Pagination options (``limit`` and ``skip``).
+            pagination: Pagination options (``limit`` and ``skip``). Merged into the
+                search query body, overriding any ``limit``/``skip`` already inside
+                ``search_query`` — useful for paginating a stored query object
+                without mutating it.
             transaction: Optional transaction context.
 
         Returns:
-            List[Relationship]: Relationships matching the search criteria.
+            SearchResult[Relationship]: Matching relationships with ``total`` count.
+                Iterable and indexable like a list; each item includes ``sourceId``,
+                ``sourceLabel``, ``targetId``, ``targetLabel``, ``type``,
+                ``direction``, and user-defined edge ``properties``.
 
         Raises:
             RushDBError: If the server request fails.
 
         Example:
             >>> relations_api = RelationsAPI(client)
-            >>> all_rels = relations_api.find()
-            >>> page = relations_api.find(pagination={"limit": 50, "skip": 0})
+            >>> result = relations_api.find({
+            ...     "source": {"labels": ["MOVIE"], "where": {"title": "Inception"}},
+            ...     "target": {"labels": ["ACTOR"]},
+            ...     "where": {"type": "STARS_IN", "role": "lead"},
+            ...     "limit": 50,
+            ... })
+            >>> result.total
+            1
+            >>> result[0]["properties"]["role"]
+            'lead'
         """
-        # Build query string for pagination
-        query_params = {}
+        # Pagination lives in the body, same as records search. The `pagination`
+        # argument overrides limit/skip inside `search_query` without mutating it.
+        payload: typing.Dict[str, typing.Any] = dict(search_query or {})
         if pagination:
             if pagination.get("limit") is not None:
-                query_params["limit"] = str(pagination["limit"])
+                payload["limit"] = pagination["limit"]
             if pagination.get("skip") is not None:
-                query_params["skip"] = str(pagination["skip"])
-
-        # Construct path with query string
-        query_string = f"?{urlencode(query_params)}" if query_params else ""
-        path = f"/relationships/search{query_string}"
+                payload["skip"] = pagination["skip"]
 
         # Build headers with transaction if present
         headers = Transaction._build_transaction_header(transaction)
@@ -111,12 +126,17 @@ class RelationsAPI(BaseAPI):
         # Make request
         response = self.client._make_request(
             method="POST",
-            path=path,
-            data=typing.cast(typing.Dict[str, typing.Any], search_query or {}),
+            path="/relationships/search",
+            data=payload,
             headers=headers,
         )
 
-        return response.get("data", [])
+        data = response.get("data", [])
+        return SearchResult(
+            data=data,
+            total=response.get("total"),
+            search_query=typing.cast(typing.Any, payload),
+        )
 
     def create_many(
         self,
@@ -125,6 +145,7 @@ class RelationsAPI(BaseAPI):
         target: dict,
         type: Optional[str] = None,
         direction: Optional[str] = None,
+        properties: Optional[dict] = None,
         many_to_many: Optional[bool] = None,
         transaction: Optional[Union[Transaction, str]] = None,
     ) -> dict:
@@ -139,6 +160,7 @@ class RelationsAPI(BaseAPI):
             target (dict): { label: str, key?: str, where?: dict }
             type (str, optional): Relationship type override.
             direction (str, optional): 'in' | 'out'. Defaults to 'out' server-side when omitted.
+            properties (dict, optional): Shared user-defined properties to store on created edges.
             many_to_many (bool, optional): Enable cartesian mode (requires filters, disallows keys).
             transaction (Transaction|str, optional): Transaction context.
 
@@ -151,6 +173,8 @@ class RelationsAPI(BaseAPI):
             payload["type"] = type
         if direction:
             payload["direction"] = direction
+        if properties is not None:
+            payload["properties"] = properties
         if many_to_many is not None:
             payload["manyToMany"] = many_to_many
         return self.client._make_request(

rushdb-2.3.0/src/rushdb/models/__init__.py

@@ -0,0 +1,30 @@
+from .property import Property
+from .record import Record
+from .relationship import (
+    Relationship,
+    RelationshipDetachOptions,
+    RelationshipDirection,
+    RelationshipOptions,
+)
+from .result import RecordSearchResult, SearchResult
+from .search_query import (
+    RelationshipEndpointQuery,
+    RelationshipSearchQuery,
+    SearchQuery,
+)
+from .transaction import Transaction
+
+__all__ = [
+    "Property",
+    "Record",
+    "Relationship",
+    "RelationshipDetachOptions",
+    "RelationshipDirection",
+    "RelationshipOptions",
+    "RecordSearchResult",
+    "SearchResult",
+    "SearchQuery",
+    "RelationshipEndpointQuery",
+    "RelationshipSearchQuery",
+    "Transaction",
+]

{rushdb-2.2.0 → rushdb-2.3.0}/src/rushdb/models/relationship.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, TypedDict, Union
+from typing import Any, Dict, List, Literal, Optional, TypedDict, Union
 
 RelationshipDirection = Literal["in", "out"]
 
@@ -7,8 +7,10 @@ class Relationship(TypedDict, total=False):
     targetLabel: str
     targetId: str
     type: str
+    direction: RelationshipDirection
     sourceId: str
     sourceLabel: str
+    properties: Dict[str, Any]
 
 
 class RelationshipOptions(TypedDict, total=False):
@@ -16,6 +18,7 @@ class RelationshipOptions(TypedDict, total=False):
 
     direction: Optional[RelationshipDirection]
     type: Optional[str]
+    properties: Optional[Dict[str, Any]]
 
 
 class RelationshipDetachOptions(TypedDict, total=False):

rushdb-2.3.0/src/rushdb/models/search_query.py

@@ -0,0 +1,37 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, TypedDict, Union
+
+
+class OrderDirection(str, Enum):
+    ASC = "asc"
+    DESC = "desc"
+
+
+class SearchQuery(TypedDict, total=False):
+    """TypedDict representing the query structure for finding records."""
+
+    where: Optional[Dict[str, Any]]
+    labels: Optional[List[str]]
+    skip: Optional[int]
+    limit: Optional[int]
+    orderBy: Optional[Union[Dict[str, OrderDirection], OrderDirection]]
+    select: Optional[Dict[str, Any]]
+    groupBy: Optional[List[str]]
+
+
+class RelationshipEndpointQuery(TypedDict, total=False):
+    """Endpoint record predicates for relationship search."""
+
+    where: Optional[Dict[str, Any]]
+    labels: Optional[List[str]]
+
+
+class RelationshipSearchQuery(TypedDict, total=False):
+    """TypedDict representing the query structure for finding relationship edges."""
+
+    where: Optional[Dict[str, Any]]
+    source: Optional[RelationshipEndpointQuery]
+    target: Optional[RelationshipEndpointQuery]
+    skip: Optional[int]
+    limit: Optional[int]
+    orderBy: Optional[Union[Dict[str, OrderDirection], OrderDirection]]

{rushdb-2.2.0 → rushdb-2.3.0}/tests/test_create_import.py

@@ -153,6 +153,53 @@ class TestCreateImport(TestBase):
             source=project, target=employee, options=detach_options
         )
 
+    def test_attach_with_edge_properties_and_find(self):
+        """Test attaching with edge properties and searching edges by them"""
+        movie = self.client.records.create("MOVIE", {"title": "Inception"})
+        actor = self.client.records.create("ACTOR", {"name": "Leonardo DiCaprio"})
+
+        self.client.records.attach(
+            source=movie,
+            target=actor,
+            options=RelationshipOptions(
+                type="STARS_IN",
+                direction="out",
+                properties={"role": "lead", "billing": 1},
+            ),
+        )
+
+        # where filters the edge (type + edge properties);
+        # source/target filter the endpoint records
+        result = self.client.relationships.find(
+            {
+                "source": {"labels": ["MOVIE"], "where": {"title": "Inception"}},
+                "target": {"labels": ["ACTOR"]},
+                "where": {"type": "STARS_IN", "role": "lead", "billing": {"$lte": 3}},
+            }
+        )
+
+        self.assertGreaterEqual(result.total, 1)
+        edge = next(
+            rel
+            for rel in result
+            if rel["sourceId"] == movie.id and rel["targetId"] == actor.id
+        )
+        self.assertEqual(edge["type"], "STARS_IN")
+        self.assertEqual(edge["properties"]["role"], "lead")
+        self.assertEqual(edge["properties"]["billing"], 1)
+
+        # Edge-property mismatch excludes the relationship
+        no_match = self.client.relationships.find(
+            {
+                "source": {"labels": ["MOVIE"], "where": {"title": "Inception"}},
+                "where": {"type": "STARS_IN", "role": "extra"},
+            }
+        )
+        self.assertNotIn(
+            (movie.id, actor.id),
+            [(rel["sourceId"], rel["targetId"]) for rel in no_match],
+        )
+
     def test_create_with_nested_data(self):
         """Test creating records with nested data structure"""
         data = {

rushdb-2.3.0/tests/test_relationship_patterns.py

@@ -0,0 +1,160 @@
+from unittest.mock import Mock
+
+from src.rushdb.api.records import RecordsAPI
+from src.rushdb.api.relationship_patterns import RelationshipPatternsAPI
+from src.rushdb.api.relationships import RelationsAPI
+
+
+def test_relationships_exposes_patterns_namespace():
+    client = Mock()
+
+    relationships = RelationsAPI(client)
+
+    assert isinstance(relationships.patterns, RelationshipPatternsAPI)
+
+
+def test_list_relationship_patterns():
+    client = Mock()
+    client._make_request.return_value = {
+        "data": {"patterns": [], "relationships": [], "analysis": {"status": "idle"}},
+        "success": True,
+    }
+
+    response = RelationsAPI(client).patterns.list()
+
+    client._make_request.assert_called_once_with("GET", "/relationships/patterns")
+    assert response.data["patterns"] == []
+    assert response.data["analysis"]["status"] == "idle"
+
+
+def test_mutate_relationship_patterns():
+    client = Mock()
+    client._make_request.return_value = {"data": {"deleted": True}, "success": True}
+    patterns = RelationsAPI(client).patterns
+
+    patterns.analyze()
+    client._make_request.assert_called_with(
+        "POST", "/relationships/patterns/analyze", {}
+    )
+
+    patterns.approve("pattern-id")
+    client._make_request.assert_called_with(
+        "POST", "/relationships/patterns/pattern-id/approve", {}
+    )
+
+    patterns.ignore("pattern-id")
+    client._make_request.assert_called_with(
+        "POST", "/relationships/patterns/pattern-id/ignore", {}
+    )
+
+    patterns.delete("pattern-id", delete_existing=True)
+    client._make_request.assert_called_with(
+        "DELETE",
+        "/relationships/patterns/pattern-id",
+        params={"deleteExisting": "true"},
+    )
+
+
+def test_relationships_find_uses_edge_where_and_endpoint_filters():
+    client = Mock()
+    edge = {
+        "sourceId": "user-1",
+        "sourceLabel": "USER",
+        "targetId": "order-1",
+        "targetLabel": "ORDER",
+        "type": "ORDERED",
+        "direction": "out",
+        "properties": {"confidence": 0.9},
+    }
+    client._make_request.return_value = {"data": [edge], "total": 1}
+
+    search_query = {
+        "source": {"labels": ["USER"], "where": {"status": "active"}},
+        "target": {"labels": ["ORDER"]},
+        "where": {"type": "ORDERED", "confidence": {"$gte": 0.8}},
+        "limit": 25,
+    }
+
+    response = RelationsAPI(client).find(search_query)
+
+    # Pagination travels in the body, same as records search.
+    client._make_request.assert_called_once_with(
+        method="POST",
+        path="/relationships/search",
+        data=search_query,
+        headers=None,
+    )
+    assert response.total == 1
+    assert list(response) == [edge]
+    assert response[0]["properties"]["confidence"] == 0.9
+
+
+def test_relationships_find_explicit_pagination_wins_over_query_limit():
+    client = Mock()
+    client._make_request.return_value = {"data": [], "total": 0}
+
+    search_query = {"where": {"type": "ORDERED"}, "limit": 25}
+    RelationsAPI(client).find(search_query, pagination={"limit": 10, "skip": 5})
+
+    # The pagination argument overrides limit/skip in the body, leaving the
+    # caller's search_query object untouched.
+    client._make_request.assert_called_once_with(
+        method="POST",
+        path="/relationships/search",
+        data={"where": {"type": "ORDERED"}, "limit": 10, "skip": 5},
+        headers=None,
+    )
+    assert search_query == {"where": {"type": "ORDERED"}, "limit": 25}
+
+
+def test_relationships_create_many_forwards_edge_properties():
+    client = Mock()
+    client._make_request.return_value = {"success": True}
+
+    RelationsAPI(client).create_many(
+        source={"label": "USER", "key": "id"},
+        target={"label": "ORDER", "key": "userId"},
+        type="ORDERED",
+        direction="out",
+        properties={"source": "import", "confidence": 0.9},
+    )
+
+    client._make_request.assert_called_once_with(
+        "POST",
+        "/relationships/create-many",
+        {
+            "source": {"label": "USER", "key": "id"},
+            "target": {"label": "ORDER", "key": "userId"},
+            "type": "ORDERED",
+            "direction": "out",
+            "properties": {"source": "import", "confidence": 0.9},
+        },
+        None,
+    )
+
+
+def test_records_attach_forwards_edge_properties():
+    client = Mock()
+    client._make_request.return_value = {"success": True}
+
+    RecordsAPI(client).attach(
+        source="source-id",
+        target="target-id",
+        options={
+            "type": "RELATED_TO",
+            "direction": "out",
+            "properties": {"source": "test"},
+        },
+    )
+
+    client._make_request.assert_called_once_with(
+        "POST",
+        "/relationships/source-id",
+        {
+            "targetIds": ["target-id"],
+            "type": "RELATED_TO",
+            "direction": "out",
+            "properties": {"source": "test"},
+        },
+        None,
+    )

{rushdb-2.2.0 → rushdb-2.3.0}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 2
 requires-python = ">=3.8"
 resolution-markers = [
     "python_full_version >= '3.10'",
@@ -785,7 +785,7 @@ wheels = [
 
 [[package]]
 name = "rushdb"
-version = "2.2.0"
+version = "2.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "python-dotenv", version = "1.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" },

rushdb-2.2.0/src/rushdb/models/__init__.py

@@ -1,17 +0,0 @@
-from .property import Property
-from .record import Record
-from .relationship import RelationshipDetachOptions, RelationshipOptions
-from .result import RecordSearchResult, SearchResult
-from .search_query import SearchQuery
-from .transaction import Transaction
-
-__all__ = [
-    "Property",
-    "Record",
-    "RelationshipDetachOptions",
-    "RelationshipOptions",
-    "RecordSearchResult",
-    "SearchResult",
-    "SearchQuery",
-    "Transaction",
-]

rushdb-2.2.0/src/rushdb/models/search_query.py

@@ -1,19 +0,0 @@
-from enum import Enum
-from typing import Any, Dict, List, Optional, TypedDict, Union
-
-
-class OrderDirection(str, Enum):
-    ASC = "asc"
-    DESC = "desc"
-
-
-class SearchQuery(TypedDict, total=False):
-    """TypedDict representing the query structure for finding records."""
-
-    where: Optional[Dict[str, Any]]
-    labels: Optional[List[str]]
-    skip: Optional[int]
-    limit: Optional[int]
-    orderBy: Optional[Union[Dict[str, OrderDirection], OrderDirection]]
-    select: Optional[Dict[str, Any]]
-    groupBy: Optional[List[str]]

rushdb-2.2.0/tests/test_relationship_patterns.py

@@ -1,54 +0,0 @@
-from unittest.mock import Mock
-
-from src.rushdb.api.relationship_patterns import RelationshipPatternsAPI
-from src.rushdb.api.relationships import RelationsAPI
-
-
-def test_relationships_exposes_patterns_namespace():
-    client = Mock()
-
-    relationships = RelationsAPI(client)
-
-    assert isinstance(relationships.patterns, RelationshipPatternsAPI)
-
-
-def test_list_relationship_patterns():
-    client = Mock()
-    client._make_request.return_value = {
-        "data": {"patterns": [], "relationships": [], "analysis": {"status": "idle"}},
-        "success": True,
-    }
-
-    response = RelationsAPI(client).patterns.list()
-
-    client._make_request.assert_called_once_with("GET", "/relationships/patterns")
-    assert response.data["patterns"] == []
-    assert response.data["analysis"]["status"] == "idle"
-
-
-def test_mutate_relationship_patterns():
-    client = Mock()
-    client._make_request.return_value = {"data": {"deleted": True}, "success": True}
-    patterns = RelationsAPI(client).patterns
-
-    patterns.analyze()
-    client._make_request.assert_called_with(
-        "POST", "/relationships/patterns/analyze", {}
-    )
-
-    patterns.approve("pattern-id")
-    client._make_request.assert_called_with(
-        "POST", "/relationships/patterns/pattern-id/approve", {}
-    )
-
-    patterns.ignore("pattern-id")
-    client._make_request.assert_called_with(
-        "POST", "/relationships/patterns/pattern-id/ignore", {}
-    )
-
-    patterns.delete("pattern-id", delete_existing=True)
-    client._make_request.assert_called_with(
-        "DELETE",
-        "/relationships/patterns/pattern-id",
-        params={"deleteExisting": "true"},
-    )