linkml-store 0.3.0__py3-none-any.whl

linkml_store/utils/mongodb_utils.py

@@ -0,0 +1,145 @@
+import logging
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+from pymongo import MongoClient
+from pymongo.database import Database
+
+logger = logging.getLogger(__name__)
+
+
+def extract_connection_info(db: Database):
+    client = db.client
+
+    # Get the host and port
+    host_info = client.address
+    if host_info:
+        host, port = host_info
+    else:
+        # For replica sets or sharded clusters, we might need to get this differently
+        host = client.HOST
+        port = client.PORT
+
+    # Get the database name
+    db_name = db.name
+
+    # Get username if available
+    username = None
+    if hasattr(client, "options") and hasattr(client.options, "credentials"):
+        credentials = client.options.credentials
+        if credentials:
+            username = credentials.username
+
+    return {"host": host, "port": port, "db_name": db_name, "username": username}
+
+
+def get_connection_string(client: MongoClient):
+    """
+    Extract a connection string from the MongoClient.
+    This avoids triggering truth value testing on Database objects.
+    """
+    if client.address:
+        host, port = client.address
+        return f"{host}:{port}"
+    if hasattr(client, "address") and client.address:
+        host, port = client.address
+        return f"{host}:{port}"
+    elif client.hosts:
+        # For replica sets, return all hosts
+        return ",".join(f"{host}:{port}" for host, port in client.hosts)
+    elif hasattr(client, "HOST"):
+        # If we can't determine hosts, use the entire URI
+        parsed_uri = urlparse(client.HOST)
+        return f"{parsed_uri.hostname}:{parsed_uri.port}"
+    else:
+        raise ValueError("Unable to determine connection string from client")
+
+
+def get_connection_info(db: Database):
+    """
+    Extract connection information from the Database object.
+    """
+    # Get the name of the database
+    db_name = db.name
+
+    # Get the client's node list (this should work for single nodes and replica sets)
+    node_list = db.client.nodes
+
+    if not node_list:
+        raise ValueError("Unable to determine connection information from database")
+
+    # Use the first node in the list (for single node setups, this will be the only node)
+    first_node = node_list[0]
+    host, port = first_node
+
+    return host, port, db_name
+
+
+def get_auth_from_client(client: MongoClient):
+    """Extract authentication details from MongoClient."""
+    if hasattr(client, "_MongoClient__options"):
+        # For older versions of PyMongo
+        options = client._MongoClient__options
+    elif hasattr(client, "options"):
+        # For newer versions of PyMongo
+        options = client.options
+    else:
+        return None, None, None
+
+    if hasattr(options, "credentials"):
+        creds = options.credentials
+        return creds.username, creds.password, creds.source
+    return None, None, None
+
+
+def connection_from_handle(handle: str):
+    if handle.startswith("mongodb://"):
+        handle = handle.replace("mongodb://", "")
+    host, db = handle.split("/")
+    return host, db
+
+
+def export_mongodb(handle: str, location: str, password: Optional[str] = None):
+    host, db_name = connection_from_handle(handle)
+
+    # Construct the mongodump command
+    cmd = ["mongodump", f"--host={host}", f"--db={db_name}"]
+    logger.info(f"Exporting MongoDB database {db_name} from {host} to {location}")
+    cmd.extend(["--out", location])
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    logger.info(f"MongoDB export completed successfully. Output: {result.stdout}")
+
+
+def import_mongodb(handle: str, dump_dir: str, drop: bool = False):
+    host, db_name = connection_from_handle(handle)
+
+    # list dirs in dump_dir
+    dir_path = Path(dump_dir)
+    if not dir_path.is_dir():
+        raise ValueError(f"{dir_path} is not a dir")
+    directories = [name for name in os.listdir(dump_dir)]
+    if len(directories) != 1:
+        raise ValueError(f"Expected exactly one database in {dump_dir}, got: {directories}")
+    src_db_name = directories[0]
+
+    # Construct the mongorestore command
+    cmd = [
+        "mongorestore",
+        f"--host={host}",
+        f"--nsFrom={src_db_name}.*",
+        f"--nsTo={db_name}.*",
+        str(dump_dir),
+    ]
+
+    # Add drop option if specified
+    if drop:
+        cmd.append("--drop")
+    logger.info(f"CMD={cmd}")
+    # Execute mongorestore
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    if result.stderr:
+        logger.warning(result.stderr)
+    logger.info(f"MongoDB import completed successfully. Output: {result.stdout} // {result.stderr}")

linkml_store/utils/neo4j_utils.py

@@ -0,0 +1,42 @@
+import networkx as nx
+from py2neo import Graph
+
+
+def draw_neo4j_graph(handle="bolt://localhost:7687", auth=("neo4j", None)):
+    # Connect to Neo4j
+    graph = Graph(handle, auth=auth)
+
+    # Run a Cypher query
+    query = """
+    MATCH (n)-[r]->(m)
+    RETURN n, r, m
+    LIMIT 100
+    """
+    result = graph.run(query)
+
+    # Create a NetworkX graph
+    G = nx.DiGraph()  # Use DiGraph for directed edges
+    for record in result:
+        n = record["n"]
+        m = record["m"]
+        r = record["r"]
+        G.add_node(n["name"], label=list(n.labels or ["-"])[0])
+        G.add_node(m["name"], label=list(m.labels or ["-"])[0])
+        G.add_edge(n["name"], m["name"], type=type(r).__name__)
+
+    # Draw the graph
+    pos = nx.spring_layout(G)
+
+    # Draw nodes
+    nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=10000)
+
+    # Draw edges
+    nx.draw_networkx_edges(G, pos, edge_color="gray", arrows=True)
+
+    # Add node labels
+    node_labels = nx.get_node_attributes(G, "label")
+    nx.draw_networkx_labels(G, pos, {node: f"{node}\n({label})" for node, label in node_labels.items()}, font_size=16)
+
+    # Add edge labels
+    edge_labels = nx.get_edge_attributes(G, "type")
+    nx.draw_networkx_edge_labels(G, pos, edge_labels, font_size=16)

linkml_store/utils/object_utils.py

@@ -0,0 +1,190 @@
+import json
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+
+def object_path_update(
+    obj: Union[BaseModel, Dict[str, Any]], path: str, value: Any
+) -> Union[BaseModel, Dict[str, Any]]:
+    """
+    Updates a nested object based on a path description and a value. The path to the
+    desired field is given in dot and bracket notation (e.g., 'a[0].b.c[1]').
+
+    :param obj: The dictionary object to be updated.
+    :type obj: Dict[str, Any]
+    :param path: The path string indicating where to place the value within the object.
+    :type path: str
+    :param value: The value to be set at the specified path.
+    :type value: Any
+    :return: None. This function modifies the object in-place.
+    :rtype: None
+
+    **Example**::
+
+    >>> data = {}
+    >>> object_path_update(data, 'persons[0].foo.bar', 1)
+    {'persons': [{'foo': {'bar': 1}}]}
+    """
+    if isinstance(obj, BaseModel):
+        typ = type(obj)
+        obj = obj.model_dump(exclude_none=True)
+        obj = object_path_update(obj, path, value)
+        return typ(**obj)
+    obj = deepcopy(obj)
+    ret_obj = obj
+    parts = path.split(".")
+    for part in parts[:-1]:
+        if "[" in part:
+            key, index = part[:-1].split("[")
+            index = int(index)
+            # obj = obj.setdefault(key, [{} for _ in range(index+1)])
+            obj = obj.setdefault(key, [])
+            while len(obj) <= index:
+                obj.append({})
+            obj = obj[index]
+        else:
+            if part in obj and obj[part] is None:
+                del obj[part]
+            obj = obj.setdefault(part, {})
+    last_part = parts[-1]
+    if "[" in last_part:
+        key, index = last_part[:-1].split("[")
+        index = int(index)
+        if key not in obj or not isinstance(obj[key], list):
+            obj[key] = [{} for _ in range(index + 1)]
+        obj[key][index] = value
+    else:
+        obj[last_part] = value
+    return ret_obj
+
+
+def object_path_get(obj: Union[BaseModel, Dict[str, Any]], path: str, default_value=None) -> Any:
+    """
+    Retrieves a value from a nested object based on a path description. The path to the
+    desired field is given in dot and bracket notation (e.g., 'a[0].b.c[1]').
+
+    :param obj: The dictionary object to be updated.
+    :type obj: Dict[str, Any]
+    :param path: The path string indicating where to place the value within the object.
+    :type path: str
+    :return: The value at the specified path.
+    :rtype: Any
+
+    **Example**::
+
+    >>> data = {'persons': [{'foo': {'bar': 1}}]}
+    >>> object_path_get(data, 'persons[0].foo.bar')
+    1
+    >>> object_path_get(data, 'persons[0].foo')
+    {'bar': 1}
+    >>> object_path_get({}, 'not there', "NA")
+    'NA'
+    """
+    if isinstance(obj, BaseModel):
+        obj = obj.model_dump()
+    parts = path.split(".")
+    for part in parts:
+        if "[" in part:
+            key, index = part[:-1].split("[")
+            index = int(index)
+            if key in obj and obj[key] is not None:
+                obj = obj[key][index]
+            else:
+                return default_value
+        else:
+            if isinstance(obj, list):
+                obj = [v1.get(part, default_value) for v1 in obj]
+            else:
+                obj = obj.get(part, default_value)
+    return obj
+
+
+def parse_update_expression(expr: str) -> Union[tuple[str, Any], None]:
+    """
+    Parse a string expression of the form 'path.to.field=value' into a path and a value.
+
+    :param expr:
+    :return:
+    """
+    try:
+        path, val = expr.split("=", 1)
+        val = json.loads(val)
+    except ValueError:
+        return None
+    return path, val
+
+
+def clean_empties(value: Union[Dict, List]) -> Any:
+    if isinstance(value, dict):
+        value = {k: v for k, v in ((k, clean_empties(v)) for k, v in value.items()) if v is not None}
+    elif isinstance(value, list):
+        value = [v for v in (clean_empties(v) for v in value) if v is not None]
+    return value
+
+
+def select_nested(data: dict, paths: List[Union[str, List[str]]], current_path=None) -> Optional[dict]:
+    """
+    Select nested attributes from a complex dictionary based on selector strings.
+
+    Args:
+    data (dict): The input nested dictionary.
+    paths (list): A list of selector strings.
+
+    Returns:
+    dict: A new dictionary with the same structure, but only the selected attributes.
+
+    Example:
+    >>> data = {
+    ...     "person": {
+    ...         "name": "John Doe",
+    ...         "age": 30,
+    ...         "address": {
+    ...             "street": "123 Main St",
+    ...             "city": "Anytown",
+    ...             "country": "USA"
+    ...         },
+    ...         "phones": [
+    ...             {"type": "home", "number": "555-1234"},
+    ...             {"type": "work", "number": "555-5678"}
+    ...         ]
+    ...     },
+    ...     "company": {
+    ...         "name": "Acme Inc",
+    ...         "location": "New York"
+    ...     }
+    ... }
+    >>> select_nested(data, ["person.address.street", "person.address.city"])
+    {'person': {'address': {'street': '123 Main St', 'city': 'Anytown'}}}
+    >>> select_nested(data, ["person.phones.number", "person.phones.type"])
+    {'person': {'phones': [{'type': 'home', 'number': '555-1234'}, {'type': 'work', 'number': '555-5678'}]}}
+    >>> select_nested(data, ["person"])
+    {'person': {'name': 'John Doe', 'age': 30, 'address': {'street': '123 Main St', 'city': 'Anytown',
+     'country': 'USA'}, 'phones': [{'type': 'home', 'number': '555-1234'}, {'type': 'work', 'number': '555-5678'}]}}
+    >>> select_nested(data, ["person.phones.type"])
+    {'person': {'phones': [{'type': 'home'}, {'type': 'work'}]}}
+    """
+    if current_path is None:
+        current_path = []
+    matching_paths = []
+    if not paths:
+        raise ValueError("No paths provided")
+    for path in paths:
+        if isinstance(path, str):
+            path = path.split(".")
+        if path == current_path:
+            return data
+        if path[: len(current_path)] == current_path:
+            matching_paths.append(path)
+    if not matching_paths:
+        return None
+    if isinstance(data, dict):
+        new_obj = {k: select_nested(v, matching_paths, current_path + [k]) for k, v in data.items()}
+        new_obj = {k: v for k, v in new_obj.items() if v is not None}
+        return new_obj
+    if isinstance(data, list):
+        new_obj = [select_nested(v, matching_paths, current_path + []) for i, v in enumerate(data)]
+        new_obj = [v for v in new_obj if v is not None]
+        return new_obj
+    return data

linkml_store/utils/pandas_utils.py

@@ -0,0 +1,93 @@
+import logging
+from typing import Any, Dict, List, Tuple, Union
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+def flatten_dict(d: Dict[str, Any], parent_key: str = "", sep: str = ".") -> Dict[str, Any]:
+    """
+    Recursively flatten a nested dictionary.
+
+    Args:
+        d (Dict[str, Any]): The dictionary to flatten.
+        parent_key (str): The parent key for nested dictionaries.
+        sep (str): The separator to use between keys.
+
+    Returns:
+        Dict[str, Any]: A flattened dictionary.
+
+    >>> flatten_dict({'a': 1, 'b': {'c': 2, 'd': {'e': 3}}})
+    {'a': 1, 'b.c': 2, 'b.d.e': 3}
+    """
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def nested_objects_to_dataframe(data: List[Dict[str, Any]]) -> pd.DataFrame:
+    """
+    Convert a list of nested objects to a flattened pandas DataFrame.
+
+    Args:
+        data (List[Dict[str, Any]]): A list of nested dictionaries.
+
+    Returns:
+        pd.DataFrame: A flattened DataFrame.
+
+    >>> data = [
+    ...     {"person": {"name": "Alice", "age": 30}, "job": {"title": "Engineer", "salary": 75000}},
+    ...     {"person": {"name": "Bob", "age": 35}, "job": {"title": "Manager", "salary": 85000}}
+    ... ]
+    >>> df = nested_objects_to_dataframe(data)
+    >>> df.columns.tolist()
+    ['person.name', 'person.age', 'job.title', 'job.salary']
+    >>> df['person.name'].tolist()
+    ['Alice', 'Bob']
+    """
+    flattened_data = [flatten_dict(item) for item in data]
+    return pd.DataFrame(flattened_data)
+
+
+def facet_summary_to_dataframe_unmelted(
+    facet_summary: Dict[Union[str, Tuple[str, ...]], List[Tuple[Union[str, Tuple[str, ...]], int]]],
+) -> pd.DataFrame:
+    rows = []
+
+    for facet_type, facet_data in facet_summary.items():
+        if isinstance(facet_type, str):
+            # Single facet type
+            for category, value in facet_data:
+                rows.append({facet_type: category, "Value": value})
+        else:
+            # Multiple facet types
+            for cat_val_tuple in facet_data:
+                if len(cat_val_tuple) == 2:
+                    categories, value = cat_val_tuple
+                else:
+                    categories, value = cat_val_tuple[:-1], cat_val_tuple[-1]
+                row = {"Value": value}
+                for i, facet in enumerate(facet_type):
+                    logger.debug(f"FT={facet_type} i={i} Facet: {facet}, categories: {categories}")
+                    row[facet] = categories[i] if len(categories) > i else None
+                rows.append(row)
+
+    df = pd.DataFrame(rows)
+
+    # Ensure all columns are present, fill with None if missing
+    all_columns = set(col for facet in facet_summary.keys() for col in (facet if isinstance(facet, tuple) else [facet]))
+    for col in all_columns:
+        if col not in df.columns:
+            df[col] = None
+
+    # Move 'Value' to the end
+    cols = [col for col in df.columns if col != "Value"] + ["Value"]
+    df = df[cols]
+
+    return df

linkml_store/utils/patch_utils.py

@@ -0,0 +1,126 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+import jsonpatch
+
+
+class PatchDict(TypedDict):
+    op: str
+    path: str
+    value: Optional[Any]
+    _from: Optional[str]
+
+
+def apply_patches(obj: Any, patches: List[PatchDict], primary_key: Optional[str] = None, in_place=False) -> Any:
+    """
+    Apply a set of patches to an object.
+
+    If the object is a list, the primary key must be specified.
+
+    >>> objs = [{'id': 'F1', 'name': 'Cheese'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> patches = [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}]
+    >>> apply_patches(objs, patches, primary_key='id')
+    [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': 'Bread'}]
+
+    :param obj: object to patch
+    :param patches: list of patches, conforming to the JSON Patch format
+    :param primary_key: key to use as the primary key for the objects (if obj is a list)
+    :param in_place: whether to apply the patches in place
+    :return:
+    """
+    if isinstance(obj, dict):
+        patch_obj = jsonpatch.JsonPatch(patches)
+        return patch_obj.apply(obj, in_place=in_place)
+    elif isinstance(obj, list):
+        if not primary_key:
+            raise ValueError("Primary key must be specified for list objects")
+        return apply_patches_to_list(obj, patches, primary_key, in_place=in_place)
+    else:
+        raise ValueError(f"Unsupported object type: {type(obj)}")
+
+
+def apply_patches_to_list(
+    objects: List[Dict[str, Any]], patches: List[PatchDict], primary_key: str, in_place=False
+) -> List[Dict[str, Any]]:
+    """
+    Apply a set of patches to a list of objects.
+
+
+
+    :param objects: list of objects
+    :param patches: list of patches, conforming to the JSON Patch format
+    :param primary_key: key to use as the primary key for the objects
+    :param in_place: whether to apply the patches in place
+    :return:
+    """
+    objs_as_dict = {obj[primary_key]: obj for obj in objects}
+    result = apply_patches_to_keyed_list(objs_as_dict, patches, in_place=in_place)
+    return list(result.values())
+
+
+def apply_patches_to_keyed_list(
+    objs_as_dict: Dict[str, Dict[str, Any]], patches: List[PatchDict], in_place=False
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Apply a set of patches to a list of objects, where the objects are keyed by a primary key
+
+    :param objs_as_dict:
+    :param patches:
+    :param in_place:
+    :return:
+    """
+    patch_obj = jsonpatch.JsonPatch(patches)
+    result = patch_obj.apply(objs_as_dict, in_place=in_place)
+    return result
+
+
+def patches_from_objects_lists(
+    src_objs: List[Dict[str, Any]], dst_objs: List[Dict[str, Any]], primary_key: str, exclude_none=True
+) -> List[PatchDict]:
+    """
+    Generate a set of patches to transform src_objs into tgt_objs.
+
+    >>> src_objs = [{'id': 'F1', 'name': 'Cheese'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> tgt_objs = [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': 'Bread'}]
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id')
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}]
+
+    by default exclude_none is True, so None values are excluded from the patch
+
+    >>> tgt_objs = [{'id': 'F1', 'name': 'Toast'}, {'id': 'F2', 'name': None}]
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id')
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}, {'op': 'remove', 'path': '/F2/name'}]
+
+    if exclude_none is False, None values are treated as being set to None
+
+    >>> patches_from_objects_lists(src_objs, tgt_objs, primary_key='id', exclude_none=False)
+    [{'op': 'replace', 'path': '/F1/name', 'value': 'Toast'}, {'op': 'replace', 'path': '/F2/name', 'value': None}]
+
+    See also: `<https://github.com/orgs/linkml/discussions/1975>`_
+
+    Note the patches are sorted deterministically, first by path, then by operation.
+    This helps ensure operations on the same object are grouped together
+
+    :param src_objs: source objects
+    :param dst_objs: target objects
+    :param primary_key: key to use as the primary key for the objects
+    :param exclude_none: whether to exclude None values from the patch
+    :return:
+    """
+    src_objs_as_dict = {obj[primary_key]: obj for obj in src_objs}
+    dst_objs_as_dict = {obj[primary_key]: obj for obj in dst_objs}
+    if exclude_none:
+        src_objs_as_dict = {k: remove_nones(v) for k, v in src_objs_as_dict.items()}
+        dst_objs_as_dict = {k: remove_nones(v) for k, v in dst_objs_as_dict.items()}
+    patch_obj = jsonpatch.JsonPatch.from_diff(src_objs_as_dict, dst_objs_as_dict)
+    pl = patch_obj.patch
+    return sorted(pl, key=lambda x: (x["path"], x["op"]))
+
+
+def remove_nones(obj: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Remove None values from a dictionary.
+
+    :param obj:
+    :return:
+    """
+    return {k: v for k, v in obj.items() if v is not None}

linkml_store/utils/query_utils.py

@@ -0,0 +1,89 @@
+import operator
+from typing import Any, Callable, Dict
+
+MONGO_OPERATORS = {
+    "$eq": operator.eq,
+    "$ne": operator.ne,
+    "$gt": operator.gt,
+    "$gte": operator.ge,
+    "$lt": operator.lt,
+    "$lte": operator.le,
+    "$in": lambda a, b: any(x in b for x in (a if isinstance(a, list) else [a])),
+    "$nin": lambda a, b: all(x not in b for x in (a if isinstance(a, list) else [a])),
+}
+
+
+def mongo_query_to_match_function(where: Dict[str, Any]) -> Callable[[Dict[str, Any]], bool]:
+    """
+    Convert a MongoDB-style query to a matching function.
+
+    >>> query = {"name": "foo", "age": {"$gt": 25}}
+    >>> matcher = mongo_query_to_match_function(query)
+    >>> matcher({"name": "foo", "age": 30})
+    True
+    >>> matcher({"name": "foo", "age": 20})
+    False
+    >>> matcher({"name": "bar", "age": 30})
+    False
+
+    >>> nested_query = {"nested.job": "engineer", "skills": {"$in": ["python", "mongodb"]}}
+    >>> nested_matcher = mongo_query_to_match_function(nested_query)
+    >>> nested_matcher({"nested": {"job": "engineer"}, "skills": ["python", "javascript"]})
+    True
+    >>> nested_matcher({"nested": {"job": "designer"}, "skills": ["python", "mongodb"]})
+    False
+    >>> nested_matcher({"nested": {"job": "engineer"}, "skills": ["java", "c++"]})
+    False
+
+    >>> complex_query = {"name": "foo", "age": {"$gte": 25, "$lt": 40}, "nested.salary": {"$gt": 50000}}
+    >>> complex_matcher = mongo_query_to_match_function(complex_query)
+    >>> complex_matcher({"name": "foo", "age": 30, "nested": {"salary": 60000}})
+    True
+    >>> complex_matcher({"name": "foo", "age": 45, "nested": {"salary": 70000}})
+    False
+    >>> complex_matcher({"name": "foo", "age": 35, "nested": {"salary": 40000}})
+    False
+
+    >>> invalid_query = {"age": {"$invalid": 25}}
+    >>> invalid_matcher = mongo_query_to_match_function(invalid_query)
+    >>> invalid_matcher({"age": 30})
+    Traceback (most recent call last):
+    ...
+    ValueError: Unsupported operator: $invalid
+    """
+    if where is None:
+        where = {}
+
+    def matches(obj: Dict[str, Any]) -> bool:
+        def check_condition(key: str, condition: Any) -> bool:
+            if isinstance(condition, dict) and any(k.startswith("$") for k in condition.keys()):
+                for op, value in condition.items():
+                    if op in MONGO_OPERATORS:
+                        if not MONGO_OPERATORS[op](get_nested_value(obj, key), value):
+                            return False
+                    else:
+                        raise ValueError(f"Unsupported operator: {op}")
+            elif isinstance(condition, dict):
+                return check_nested_condition(get_nested_value(obj, key), condition)
+            else:
+                return get_nested_value(obj, key) == condition
+            return True
+
+        def check_nested_condition(nested_obj: Dict[str, Any], nested_condition: Dict[str, Any]) -> bool:
+            for k, v in nested_condition.items():
+                if not check_condition(k, v):
+                    return False
+            return True
+
+        def get_nested_value(obj: Dict[str, Any], key: str) -> Any:
+            parts = key.split(".")
+            for part in parts:
+                if isinstance(obj, dict):
+                    obj = obj.get(part)
+                else:
+                    return None
+            return obj
+
+        return all(check_condition(k, v) for k, v in where.items())
+
+    return matches