linkml-store 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

linkml_store/cli.py

@@ -14,7 +14,7 @@ from linkml_store.api.queries import Query
 from linkml_store.index import get_indexer
 from linkml_store.index.implementations.simple_indexer import SimpleIndexer
 from linkml_store.index.indexer import Indexer
-from linkml_store.utils.format_utils import Format, guess_format, load_objects, render_output
+from linkml_store.utils.format_utils import Format, guess_format, load_objects, render_output, write_output
 from linkml_store.utils.object_utils import object_path_update
 
 index_type_option = click.option(
@@ -159,7 +159,15 @@ def cli(ctx, verbose: int, quiet: bool, stacktrace: bool, database, collection,
 @click.option("--object", "-i", multiple=True, help="Input object as YAML")
 @click.pass_context
 def insert(ctx, files, object, format):
-    """Insert objects from files (JSON, YAML, TSV) into the specified collection."""
+    """Insert objects from files (JSON, YAML, TSV) into the specified collection.
+
+    Using a configuration:
+
+        linkml-store -C config.yaml -c genes insert data/genes/*.json
+
+    Note: if you don't provide a schema this will be inferred, but it is
+    usually better to provide an explicit schema
+    """
     settings = ctx.obj["settings"]
     collection = settings.collection
     if not collection:
@@ -181,6 +189,7 @@ def insert(ctx, files, object, format):
             objects = yaml.safe_load(object_str)
             collection.insert(objects)
             click.echo(f"Inserted {len(objects)} objects from {object_str} into collection '{collection.name}'.")
+    collection.commit()
 
 
 @cli.command()
@@ -213,9 +222,9 @@ def store(ctx, files, object, format):
 
 
 @cli.command(name="import")
-@click.argument("files", type=click.Path(exists=True), nargs=-1)
 @click.option("--format", "-f", help="Input format")
 @click.pass_context
+@click.argument("files", type=click.Path(exists=True), nargs=-1)
 def import_database(ctx, files, format):
     """Imports a database from a dump."""
     settings = ctx.obj["settings"]
@@ -242,13 +251,77 @@ def export(ctx, output_type, output):
 
 
 @cli.command()
-@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--output-type", "-O", type=format_choice, default="json", help="Output format")
+@click.option("--other-database", "-D", required=False, help="Path to the other database")
+@click.option("--other-collection", "-X", required=True, help="Name of the other collection")
+@click.option("--identifier-attribute", "-I", required=False, help="Primary key name")
+@click.pass_context
+def diff(ctx, output, output_type, other_database, other_collection, identifier_attribute):
+    """Diffs two collectoons to create a patch."""
+    settings = ctx.obj["settings"]
+    db = settings.database
+    collection = settings.collection
+    if not collection:
+        raise ValueError("Collection must be specified.")
+    other_db = settings.client.get_database(other_database) if other_database else db
+    other_collection = other_db.get_collection(other_collection)
+    if identifier_attribute:
+        collection.set_identifier_attribute_name(identifier_attribute)
+        other_collection.set_identifier_attribute_name(identifier_attribute)
+    diff = collection.diff(other_collection)
+    write_output(diff, output_type, target=output)
+
+
+@cli.command()
+@click.option("--identifier-attribute", "-I", required=False, help="Primary key name")
+@click.argument("patch_files", type=click.Path(exists=True), nargs=-1)
+@click.pass_context
+def apply(ctx, patch_files, identifier_attribute):
+    """
+    Apply a patch to a collection.
+    """
+    settings = ctx.obj["settings"]
+    collection = settings.collection
+    if not collection:
+        raise ValueError("Collection must be specified.")
+    if identifier_attribute:
+        collection.set_identifier_attribute_name(identifier_attribute)
+    for patch_file in patch_files:
+        patch_objs = load_objects(patch_file, expected_type=list)
+        collection.apply_patches(patch_objs)
+
+
+@cli.command()
+@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query, as YAML")
 @click.option("--limit", "-l", type=click.INT, help="Maximum number of results to return")
 @click.option("--output-type", "-O", type=format_choice, default="json", help="Output format")
 @click.option("--output", "-o", type=click.Path(), help="Output file path")
 @click.pass_context
 def query(ctx, where, limit, output_type, output):
-    """Query objects from the specified collection."""
+    """Query objects from the specified collection.
+
+
+    Leave the query field blank to return all objects in the collection.
+
+    Examples:
+
+        linkml-store -d duckdb:///countries.db -c countries query
+
+    Queries can be specified in YAML, as basic key-value pairs
+
+    Examples:
+
+        linkml-store -d duckdb:///countries.db -c countries query -w 'code: NZ'
+
+    More complex queries can be specified using MongoDB-style query syntax
+
+    Examples:
+
+        linkml-store -d file:. -c persons query  -w 'occupation: {$ne: Architect}'
+
+    Finds all people who are not architects.
+    """
     collection = ctx.obj["settings"].collection
     where_clause = yaml.safe_load(where) if where else None
     query = Query(from_table=collection.name, where_clause=where_clause, limit=limit)
@@ -326,6 +399,21 @@ def _get_index(index_type=None, **kwargs) -> Indexer:
         raise ValueError(f"Unknown index type: {index_type}")
 
 
+@cli.command()
+@click.option("--where", "-w", type=click.STRING, help="WHERE clause for the query")
+@click.option("--output-type", "-O", type=format_choice, default=Format.FORMATTED.value, help="Output format")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.pass_context
+def describe(ctx, where, output_type, output):
+    """
+    Describe the collection schema.
+    """
+    where_clause = yaml.safe_load(where) if where else None
+    collection = ctx.obj["settings"].collection
+    df = collection.find(where_clause, limit=1).rows_dataframe
+    write_output(df.describe(include="all").transpose(), output_type, target=output)
+
+
 @cli.command()
 @index_type_option
 @click.option("--cached-embeddings-database", "-E", help="Path to the database where embeddings are cached")
@@ -335,9 +423,7 @@ def index(ctx, index_type, **kwargs):
     """
     Create an index over a collection.
 
-    :param ctx:
-    :param index_type:
-    :return:
+    By default a simple trigram index is used.
     """
     collection = ctx.obj["settings"].collection
     ix = get_indexer(index_type, **kwargs)
@@ -397,6 +483,9 @@ def search(ctx, search_term, where, limit, index_type, output_type, output, auto
 @cli.command()
 @click.pass_context
 def indexes(ctx):
+    """
+    Show the indexes for a collection.
+    """
     collection = ctx.obj["settings"].collection
     for name, ix in collection.indexers.items():
         click.echo(f"{name}: {type(ix)}\n{ix.model_json()}")

linkml_store/index/__init__.py

@@ -22,7 +22,7 @@ def get_indexer_class(name: str) -> Type[Indexer]:
     return INDEXER_CLASSES[name]
 
 
-def get_indexer(name: str, **kwargs) -> Indexer:
+def get_indexer(index_type: str, **kwargs) -> Indexer:
     """
     Get an indexer by name.
 
@@ -31,7 +31,9 @@ def get_indexer(name: str, **kwargs) -> Indexer:
     :return: the indexer
     """
     kwargs = {k: v for k, v in kwargs.items() if v is not None}
-    cls = get_indexer_class(name)
-    kwargs["name"] = name
+    cls = get_indexer_class(index_type)
+    kwargs["index_type"] = index_type
     indexer = cls(**kwargs)
+    if not indexer.name:
+        indexer.name = index_type
     return indexer

linkml_store/index/indexer.py

@@ -28,6 +28,7 @@ class Indexer(BaseModel):
     """
 
     name: Optional[str] = None
+    index_type: Optional[str] = None
     index_function: Optional[Callable] = None
     distance_function: Optional[Callable] = None
     index_attributes: Optional[List[str]] = None
@@ -93,13 +94,17 @@ class Indexer(BaseModel):
                 if "{%" in self.text_template or "{{" in self.text_template:
                     logger.info("Detected Jinja2 syntax in text template")
                     syntax = TemplateSyntaxEnum.jinja2
-            if syntax and syntax == TemplateSyntaxEnum.jinja2:
+            if not syntax:
+                syntax = TemplateSyntaxEnum.fstring
+            if syntax == TemplateSyntaxEnum.jinja2:
                 from jinja2 import Template
 
                 template = Template(self.text_template)
                 return template.render(**obj)
-            else:
+            elif syntax == TemplateSyntaxEnum.fstring:
                 return self.text_template.format(**obj)
+            else:
+                raise NotImplementedError(f"Cannot handle template syntax: {syntax}")
         return str(obj)
 
     def search(

linkml_store/utils/change_utils.py

@@ -0,0 +1,17 @@
+from typing import List
+
+from linkml_store.api.collection import OBJECT
+
+
+def insert_operation_to_patches(objs: List[OBJECT], **kwargs):
+    """
+    Translate a list of objects to a list of patches for insertion.
+
+    Note: inserts are always treated as being at the start of a list
+
+    :param objs: objects to insert
+    :param kwargs: additional arguments
+    """
+    patches = []
+    for obj in objs:
+        patches.append({"op": "add", "path": "/0", "value": obj})

linkml_store/utils/format_utils.py

@@ -4,8 +4,9 @@ import sys
 from enum import Enum
 from io import StringIO
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, TextIO, Type, Union
 
+import pandas as pd
 import yaml
 from pydantic import BaseModel
 
@@ -20,9 +21,13 @@ class Format(Enum):
     YAML = "yaml"
     TSV = "tsv"
     CSV = "csv"
+    PARQUET = "parquet"
+    FORMATTED = "formatted"
 
 
-def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None) -> List[Dict[str, Any]]:
+def load_objects(
+    file_path: Union[str, Path], format: Union[Format, str] = None, expected_type: Type = None
+) -> List[Dict[str, Any]]:
     """
     Load objects from a file in JSON, JSONLines, YAML, CSV, or TSV format.
 
@@ -32,6 +37,7 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
 
     :param file_path: The path to the file.
     :param format: The format of the file. Can be a Format enum or a string value.
+    :param expected_type: The target type to load the objects into.
     :return: A list of dictionaries representing the loaded objects.
     """
     if isinstance(format, str):
@@ -40,24 +46,39 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
     if isinstance(file_path, Path):
         file_path = str(file_path)
 
+    if not format and (file_path.endswith(".parquet") or file_path.endswith(".pq")):
+        format = Format.PARQUET
+
+    mode = "r"
+    if format == Format.PARQUET:
+        mode = "rb"
+
     if file_path == "-":
         # set file_path to be a stream from stdin
         f = sys.stdin
     else:
-        f = open(file_path)
+        f = open(file_path, mode)
 
     if format == Format.JSON or (not format and file_path.endswith(".json")):
         objs = json.load(f)
     elif format == Format.JSONL or (not format and file_path.endswith(".jsonl")):
         objs = [json.loads(line) for line in f]
     elif format == Format.YAML or (not format and (file_path.endswith(".yaml") or file_path.endswith(".yml"))):
-        objs = yaml.safe_load(f)
+        if expected_type and expected_type == list:  # noqa E721
+            objs = list(yaml.safe_load_all(f))
+        else:
+            objs = yaml.safe_load(f)
     elif format == Format.TSV or (not format and file_path.endswith(".tsv")):
         reader = csv.DictReader(f, delimiter="\t")
         objs = list(reader)
     elif format == Format.CSV or (not format and file_path.endswith(".csv")):
         reader = csv.DictReader(f)
         objs = list(reader)
+    elif format == Format.PARQUET:
+        import pyarrow.parquet as pq
+
+        table = pq.read_table(f)
+        objs = table.to_pandas().to_dict(orient="records")
     else:
         raise ValueError(f"Unsupported file format: {file_path}")
     if not isinstance(objs, list):
@@ -65,7 +86,40 @@ def load_objects(file_path: Union[str, Path], format: Union[Format, str] = None)
     return objs
 
 
-def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Union[Format, str] = Format.YAML) -> str:
+def write_output(
+    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame],
+    format: Union[Format, str] = Format.YAML,
+    target: Optional[Union[TextIO, str, Path]] = None,
+) -> None:
+    """
+    Write output data to a file in JSON, JSONLines, YAML, CSV, or TSV format.
+
+    >>> write_output([{"a": 1, "b": 2}, {"a": 3, "b": 4}], Format.JSON, sys.stdout)
+    [
+      {
+        "a": 1,
+        "b": 2
+      },
+      {
+        "a": 3,
+        "b": 4
+        }
+    ]
+    """
+    output_str = render_output(data, format)
+    if target:
+        if isinstance(target, str):
+            with open(target, "w") as target:
+                target.write(output_str)
+        else:
+            target.write(output_str)
+    else:
+        print(output_str)
+
+
+def render_output(
+    data: Union[List[Dict[str, Any]], Dict[str, Any], pd.DataFrame], format: Union[Format, str] = Format.YAML
+) -> str:
     """
     Render output data in JSON, JSONLines, YAML, CSV, or TSV format.
 
@@ -89,6 +143,14 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
     if isinstance(format, str):
         format = Format(format)
 
+    if format == Format.FORMATTED:
+        if not isinstance(data, pd.DataFrame):
+            data = pd.DataFrame(data)
+        return str(data)
+
+    if isinstance(data, pd.DataFrame):
+        data = data.to_dict(orient="records")
+
     if isinstance(data, BaseModel):
         data = data.model_dump()
 
@@ -97,16 +159,19 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
     elif format == Format.JSONL:
         return "\n".join(json.dumps(obj) for obj in data)
     elif format == Format.YAML:
-        return yaml.safe_dump(data, sort_keys=False)
+        if isinstance(data, list):
+            return yaml.safe_dump_all(data, sort_keys=False)
+        else:
+            return yaml.safe_dump(data, sort_keys=False)
     elif format == Format.TSV:
         output = StringIO()
-        writer = csv.DictWriter(output, fieldnames=data[0].keys(), delimiter="\t")
+        writer = csv.DictWriter(output, fieldnames=get_fieldnames(data), delimiter="\t")
         writer.writeheader()
         writer.writerows(data)
         return output.getvalue()
     elif format == Format.CSV:
         output = StringIO()
-        writer = csv.DictWriter(output, fieldnames=data[0].keys())
+        writer = csv.DictWriter(output, fieldnames=get_fieldnames(data))
         writer.writeheader()
         writer.writerows(data)
         return output.getvalue()
@@ -114,6 +179,22 @@ def render_output(data: Union[List[Dict[str, Any]], Dict[str, Any]], format: Uni
         raise ValueError(f"Unsupported output format: {format}")
 
 
+def get_fieldnames(data: List[Dict[str, Any]]) -> List[str]:
+    """
+    Get the fieldnames of a list of dictionaries.
+
+    >>> get_fieldnames([{"a": 1, "b": 2}, {"a": 3, "b": 4}])
+    ['a', 'b']
+
+    :param data: The list of dictionaries.
+    :return: The fieldnames.
+    """
+    fieldnames = []
+    for obj in data:
+        fieldnames.extend([k for k in obj.keys() if k not in fieldnames])
+    return fieldnames
+
+
 def guess_format(path: str) -> Optional[Format]:
     """
     Guess the format of a file based on its extension.

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

linkml_store/utils/schema_utils.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model import SlotDefinition
+
+
+def path_to_attribute_list(class_name: str, path: str, schema_view: SchemaView) -> List[SlotDefinition]:
+    """
+    Convert a path to a list of attributes.
+
+    :param path:
+    :return:
+    """
+    parts = path.split(".")
+    att_list = []
+    while parts:
+        part = parts.pop(0)
+        att = schema_view.induced_slot(part, class_name)
+        if not att:
+            raise ValueError(f"Attribute {part} not found in class {class_name}")
+        att_list.append(att)
+        class_name = att.range
+    return att_list

linkml_store/webapi/html/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+HTML_TEMPLATES_DIR = Path(__file__).parent