linkml-store 0.3.0__py3-none-any.whl

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/utils/sklearn_utils.py

@@ -0,0 +1,193 @@
+import logging
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+import numpy as np
+from linkml_runtime.utils.formatutils import underscore
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder
+from sklearn.tree import DecisionTreeClassifier, _tree, export_graphviz
+
+logger = logging.getLogger(__name__)
+
+
+def tree_to_nested_expression(
+    tree: DecisionTreeClassifier,
+    feature_names: List[str],
+    categorical_features: Optional[List[str]] = None,
+    feature_encoders: Optional[Dict[str, Union[OneHotEncoder, LabelEncoder]]] = None,
+    target_encoder: Optional[LabelEncoder] = None,
+) -> str:
+    """
+    Convert a trained scikit-learn DecisionTreeClassifier to a nested Python conditional expression.
+
+    Args:
+    tree (DecisionTreeClassifier): A trained decision tree classifier.
+    feature_names (list): List of feature names (including one-hot encoded feature names).
+    categorical_features (list): List of original categorical feature names.
+    feature_encoders (dict): Dictionary mapping feature names to their respective OneHotEncoders or LabelEncoders.
+    target_encoder (LabelEncoder, optional): LabelEncoder for the target variable if it's categorical.
+
+    Returns:
+    str: A string representing the nested Python conditional expression.
+
+    Example:
+    >>> import numpy as np
+    >>> from sklearn.tree import DecisionTreeClassifier
+    >>> from sklearn.preprocessing import OneHotEncoder, LabelEncoder
+    >>>
+    >>> # Prepare sample data
+    >>> X = np.array([[0, 'A'], [0, 'B'], [1, 'A'], [1, 'B']])
+    >>> y = np.array(['No', 'Yes', 'Yes', 'No'])
+    >>>
+    >>> # Prepare the encoders
+    >>> feature_encoders = {'feature2': OneHotEncoder(sparse_output=False, handle_unknown='ignore')}
+    >>> target_encoder = LabelEncoder()
+    >>>
+    >>> # Encode the categorical feature and target
+    >>> X_encoded = np.column_stack([
+    ...     X[:, 0],
+    ...     feature_encoders['feature2'].fit_transform(X[:, 1].reshape(-1, 1))
+    ... ])
+    >>> y_encoded = target_encoder.fit_transform(y)
+    >>>
+    >>> # Train the decision tree
+    >>> clf = DecisionTreeClassifier(random_state=42)
+    >>> clf.fit(X_encoded, y_encoded)
+    DecisionTreeClassifier(random_state=42)
+    >>>
+    >>> # Convert to nested expression
+    >>> feature_names = ['feature1', 'feature2_A', 'feature2_B']
+    >>> categorical_features = ['feature2']
+    >>> expression = tree_to_nested_expression(clf, feature_names,
+    ...                                        categorical_features, feature_encoders, target_encoder)
+    >>> print(expression)
+    (("Yes" if ({feature1} <= 0.5000) else "No") if ({feature2} == "A")
+       else ("No" if ({feature1} <= 0.5000) else "Yes"))
+    """
+    tree_ = tree.tree_
+    feature_name = [feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!" for i in tree_.feature]
+
+    categorical_features = set(categorical_features or [])
+
+    def get_original_feature_name(name):
+        return name.split("_")[0] if "_" in name else name
+
+    def recurse(node):
+        if tree_.feature[node] != _tree.TREE_UNDEFINED:
+            name = feature_name[node]
+            threshold = tree_.threshold[node]
+            original_name = get_original_feature_name(name)
+            original_name_safe = underscore(original_name)
+            name_safe = underscore(name)
+
+            original_name_safe = "{" + original_name_safe + "}"
+            name_safe = "{" + name_safe + "}"
+
+            if original_name in categorical_features:
+                if feature_encoders is None or original_name not in feature_encoders:
+                    raise ValueError(f"Encoder is required for categorical feature {original_name}")
+
+                encoder = feature_encoders[original_name]
+                if isinstance(encoder, OneHotEncoder):
+                    # For one-hot encoded features, we check if the specific category is present
+                    category = name.split("_", 1)[1]  # Get everything after the first underscore
+                    condition = f'{original_name_safe} == "{category}"'
+                elif isinstance(encoder, LabelEncoder):
+                    category = encoder.inverse_transform([int(threshold)])[0]
+                    condition = f'{original_name_safe} == "{category}"'
+                else:
+                    raise ValueError(f"Unsupported encoder type for feature {original_name}")
+            else:
+                if np.isinf(threshold):
+                    condition = "True"
+                else:
+                    condition = f"{name_safe} <= {threshold:.4f}"
+
+            left_expr = recurse(tree_.children_left[node])
+            right_expr = recurse(tree_.children_right[node])
+
+            return f"({left_expr} if ({condition}) else {right_expr})"
+        else:
+            class_index = np.argmax(tree_.value[node])
+            if target_encoder:
+                class_label = target_encoder.inverse_transform([class_index])[0]
+                return f'"{class_label}"'
+            else:
+                return str(class_index)
+
+    return recurse(0)
+
+
+def escape_label(s: str) -> str:
+    """Escape special characters in label strings."""
+    s = str(s)
+    return re.sub(r"([<>])", r"\\\1", s)
+
+
+def visualize_decision_tree(
+    clf: DecisionTreeClassifier,
+    feature_names: List[str],
+    class_names: List[str] = None,
+    output_file: Union[Path, str] = "decision_tree.png",
+) -> None:
+    """
+    Generate a visualization of the decision tree and save it as a PNG file.
+
+    :param clf: Trained DecisionTreeClassifier
+    :param feature_names: List of feature names
+    :param class_names: List of class names (optional)
+    :param output_file: The name of the file to save the visualization (default: "decision_tree.png")
+
+    >>> # Create a sample dataset
+    >>> import pandas as pd
+    >>> data = pd.DataFrame({
+    ...     'age': [25, 30, 35, 40, 45],
+    ...     'income': [50000, 60000, 70000, 80000, 90000],
+    ...     'credit_score': [600, 650, 700, 750, 800],
+    ...     'approved': ['No', 'No', 'Yes', 'Yes', 'Yes']
+    ... })
+    >>>
+    >>> # Prepare features and target
+    >>> X = data[['age', 'income', 'credit_score']]
+    >>> y = data['approved']
+    >>>
+    >>> # Encode target variable
+    >>> le = LabelEncoder()
+    >>> y_encoded = le.fit_transform(y)
+    >>>
+    >>> # Train a decision tree
+    >>> clf = DecisionTreeClassifier(random_state=42)
+    >>> _ = clf.fit(X, y_encoded)
+    >>> # Visualize the tree
+    >>> visualize_decision_tree(clf, X.columns.tolist(), le.classes_, "tests/output/test_tree.png")
+    """
+    # Escape special characters in feature names and class names
+    escaped_feature_names = [escape_label(name) for name in feature_names]
+    escaped_class_names = [escape_label(name) for name in (class_names if class_names is not None else [])]
+
+    import graphviz
+
+    dot_data = export_graphviz(
+        clf,
+        out_file=None,
+        feature_names=escaped_feature_names,
+        class_names=escaped_class_names,
+        filled=True,
+        rounded=True,
+        special_characters=True,
+    )
+    # dot_data = escape_label(dot_data)
+    logger.info(f"Dot: {dot_data}")
+    dot_path = shutil.which("dot")
+    if not dot_path:
+        logger.warning("Graphviz 'dot' executable not found in PATH. Skipping visualization.")
+        return
+    os.environ["GRAPHVIZ_DOT"] = dot_path
+
+    graph = graphviz.Source(dot_data)
+    if isinstance(output_file, Path):
+        output_file = str(output_file)
+    graph.render(output_file.rsplit(".", 1)[0], format="png", cleanup=True)

linkml_store/utils/sql_utils.py

@@ -0,0 +1,177 @@
+import logging
+from typing import Any, Optional, Tuple, Type, Union
+
+import sqlalchemy
+import sqlalchemy.sql.sqltypes as sqlt
+from linkml_runtime.linkml_model import SchemaDefinition, SlotDefinition
+from linkml_runtime.utils.schema_builder import SchemaBuilder
+from sqlalchemy import MetaData, quoted_name
+
+from linkml_store.api.queries import Query
+
+logger = logging.getLogger(__name__)
+
+TYPE_MAP = {
+    sqlt.TEXT: "string",
+    sqlt.INTEGER: "integer",
+    sqlt.FLOAT: "float",
+}
+
+OP_MAP = {
+    "eq": "=",
+    "$in": "ARRAY_CONTAINS",  ## mongodb
+    "$contains": "ARRAY_CONTAINS",  ## TODO: this is chromadb-specific
+    "in": "ARRAY_CONTAINS",
+}
+
+
+def _map_type(typ: Type) -> str:
+    for k, v in TYPE_MAP.items():
+        if isinstance(typ, k):
+            return v
+    return "string"
+
+
+def where_clause_to_sql(query: Query) -> str:
+    if not query.where_clause:
+        return ""
+    if isinstance(query.where_clause, str):
+        where_clause_sql = query.where_clause
+    elif isinstance(query.where_clause, list):
+        where_clause_sql = " AND ".join(query.where_clause)
+    elif isinstance(query.where_clause, dict):
+        conjs = []
+        for k, v in query.where_clause.items():
+            conjs.extend(col_val_constraints_to_conjs(k, v))
+        where_clause_sql = " AND ".join(conjs)
+
+    else:
+        raise ValueError(f"Invalid where_clause type: {type(query.where_clause)}")
+    return "WHERE " + where_clause_sql
+
+
+def col_val_constraints_to_conjs(col_name: str, val_constraints: Any) -> list:
+    if val_constraints is None:
+        return []
+
+    def _quote(v: Any):
+        if isinstance(v, str):
+            # escape internal vs
+            v = v.replace("'", "''")
+            return f"'{v}'"
+        else:
+            return v
+
+    if isinstance(val_constraints, dict):
+        conjs = []
+        for k, v in val_constraints.items():
+            if k in OP_MAP:
+                if k == "$in" and isinstance(v, list):
+                    v_mapped = [_quote(v1) for v1 in v]
+                    t = f"{col_name} IN ({', '.join(v_mapped)})"
+                else:
+                    t = f"{OP_MAP[k]}({col_name}, {_quote(v)})"
+            else:
+                t = f"{col_name} {k} {_quote(v)}"
+            conjs.append(t)
+        return conjs
+    else:
+        return [f"{col_name} = {_quote(val_constraints)}"]
+
+
+def query_to_sql(query: Query, count=False, limit=None, offset: Optional[int] = None):
+    select_cols = query.select_cols if query.select_cols else ["*"]
+    if count:
+        sql_str = ["SELECT COUNT(*)"]
+    else:
+        sql_str = [f"SELECT {', '.join(select_cols)}"]
+    sql_str.append(f"FROM {query.from_table}")
+    sql_str.append(where_clause_to_sql(query))
+    if not count:
+        if query.sort_by:
+            sql_str.append(f"ORDER BY {', '.join(query.sort_by)}")
+    if not count:
+        if limit is None:
+            limit = query.limit
+        if limit is None:
+            limit = 100
+        if limit < 0:
+            limit = None
+        if limit is not None:
+            sql_str.append(f" LIMIT {limit}")
+        offset = offset if offset else query.offset
+        if offset:
+            sql_str.append(f" OFFSET {offset}")
+    sql_str = [line for line in sql_str if line]
+    return "\n".join(sql_str)
+
+
+def facet_count_sql(query: Query, facet_column: Union[str, Tuple[str, ...]], multivalued=False, limit=100) -> str:
+    # Create a modified WHERE clause that excludes conditions directly related to facet_column
+    modified_where = None
+    if query.where_clause:
+        where_clause_sql = where_clause_to_sql(query)
+        # Split the where clause into conditions and exclude those related to the facet_column
+        conditions = [cond for cond in where_clause_sql.split(" AND ") if not cond.startswith(f"{facet_column} ")]
+        modified_where = " AND ".join(conditions)
+
+    def make_col_safe(col):
+        return '"' + quoted_name(col, True) + '"' if " " in col else col
+
+    if isinstance(facet_column, str):
+        facet_column = make_col_safe(facet_column)
+    if isinstance(facet_column, tuple):
+        facet_column = [make_col_safe(col) for col in facet_column]
+        if multivalued:
+            raise NotImplementedError("Multivalued facets are not supported for multiple columns")
+        facet_column = ", ".join(facet_column)
+    from_table = query.from_table
+    if multivalued:
+        from_table = f"(SELECT UNNEST({facet_column}) as {facet_column} FROM {query.from_table}"
+        from_table += f" {modified_where}" if modified_where else ""
+        from_table += ")"
+    else:
+        from_table += f" {modified_where}" if modified_where else ""
+    sql_str = [f"SELECT {facet_column}, COUNT(*) as count", f"FROM {from_table}"]
+    # if modified_where:
+    #    sql_str.append(f"{modified_where}")
+    sql_str.append(f"GROUP BY {facet_column}")
+    sql_str.append("ORDER BY count DESC")  # Optional, order by count for convenience
+    if limit is not None:
+        sql_str.append(f"LIMIT {limit}")
+    return "\n".join(sql_str)
+
+
+def introspect_schema(engine: sqlalchemy.Engine) -> SchemaDefinition:
+    """
+    Introspect a database schema and return a SchemaDefinition object
+
+    :param engine:
+    :return:
+    """
+    metadata_obj = MetaData()
+    logging.info(f"Reflecting using {engine}")
+    metadata_obj.reflect(bind=engine)
+    sb = SchemaBuilder()
+    schema = sb.schema
+    for table in metadata_obj.sorted_tables:
+        logging.info(f"Importing {table.name}")
+        sb.add_class(table.name)
+        cls = schema.classes[table.name]
+        pks = [column for column in table.columns if column.primary_key]
+        if len(pks) == 1:
+            pk = pks.pop().name
+        else:
+            pk = None
+        for column in table.columns:
+            slot = SlotDefinition(column.name)
+            cls.attributes[slot.name] = slot
+            if pk and pk == column.name:
+                slot.identifier = True
+            if column.foreign_keys:
+                for fk in column.foreign_keys:
+                    [fk_table, fk_table_col] = str(fk.column).split(".")
+                    slot.range = fk_table
+            else:
+                slot.range = _map_type(column.type)
+    return schema

linkml_store/utils/stats_utils.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pandas as pd
+
+
+def predictive_power(df, target_col, feature_cols, cv=5):
+    from sklearn.model_selection import cross_val_score
+    from sklearn.preprocessing import LabelEncoder
+    from sklearn.tree import DecisionTreeClassifier
+
+    # Prepare the data
+    X = df[feature_cols].copy()  # Create an explicit copy
+    y = df[target_col].copy()
+
+    # Encode categorical variables
+    for col in X.columns:
+        if X[col].dtype == "object":
+            X[col] = LabelEncoder().fit_transform(X[col].astype(str))
+
+    if y.dtype == "object":
+        y = LabelEncoder().fit_transform(y.astype(str))
+
+    # Adjust cv based on the number of unique values in y
+    n_unique = len(np.unique(y))
+    cv = min(cv, n_unique)
+
+    # Train a decision tree and get cross-validated accuracy
+    clf = DecisionTreeClassifier(random_state=42)
+
+    if cv < 2:
+        # If cv is less than 2, we can't do cross-validation, so we'll just fit and score
+        clf.fit(X, y)
+        return clf.score(X, y)
+    else:
+        scores = cross_val_score(clf, X, y, cv=cv)
+        return scores.mean()
+
+
+def analyze_predictive_power(df, columns=None, cv=5):
+    if columns is None:
+        columns = df.columns
+    results = pd.DataFrame(index=columns, columns=["predictive_power", "features"])
+
+    for target_col in columns:
+        feature_cols = [col for col in columns if col != target_col]
+        try:
+            power = predictive_power(df, target_col, feature_cols, cv)
+            results.loc[target_col, "predictive_power"] = power
+            results.loc[target_col, "features"] = ", ".join(feature_cols)
+        except Exception as e:
+            print(f"Error processing {target_col}: {str(e)}")
+            results.loc[target_col, "predictive_power"] = np.nan
+
+    return results

linkml_store/utils/vector_utils.py

@@ -0,0 +1,158 @@
+import logging
+from typing import List, Tuple
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+LOL = List[List[float]]
+
+
+def pairwise_cosine_similarity(vector1: np.array, vector2: np.array) -> float:
+    """
+    Calculate the cosine similarity between two vectors.
+
+    >>> v100 = np.array([1, 0, 0])
+    >>> v010 = np.array([0, 1, 0])
+    >>> v001 = np.array([0, 0, 1])
+    >>> v011 = np.array([0, 1, 1])
+    >>> pairwise_cosine_similarity(v100, v010)
+    0.0
+    >>> pairwise_cosine_similarity(v100, v001)
+    0.0
+    >>> pairwise_cosine_similarity(v010, v001)
+    0.0
+    >>> pairwise_cosine_similarity(v100, v100)
+    1.0
+    >>> f"{pairwise_cosine_similarity(v010, v011):0.3f}"
+    '0.707'
+
+    :param vector1:
+    :param vector2:
+    :return:
+    """
+    dot_product = np.dot(vector1, vector2)
+    norm1 = np.linalg.norm(vector1)
+    norm2 = np.linalg.norm(vector2)
+    return float(dot_product / (norm1 * norm2))
+
+
+def compute_cosine_similarity_matrix(list1: LOL, list2: LOL) -> np.ndarray:
+    """
+    Compute cosine similarity between two lists of vectors.
+
+    Result is a two column vector sim[ROW][COL] where ROW is from list1 and COL is from list2.
+
+    :param list1:
+    :param list2:
+    :return:
+    """
+    # Convert lists to numpy arrays
+    matrix1 = np.array(list1)
+    matrix2 = np.array(list2)
+
+    # Normalize the vectors in both matrices
+    matrix1_norm = matrix1 / np.linalg.norm(matrix1, axis=1)[:, np.newaxis]
+    matrix2_norm = matrix2 / np.linalg.norm(matrix2, axis=1)[:, np.newaxis]
+
+    # Compute dot products (resulting in cosine similarity values)
+    cosine_similarity_matrix = np.dot(matrix1_norm, matrix2_norm.T)
+
+    return cosine_similarity_matrix
+
+
+def top_matches(cosine_similarity_matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Find the top match for each row in the cosine similarity matrix.
+
+    :param cosine_similarity_matrix:
+    :return:
+    """
+    # Find the index of the maximum value in each row
+    top_match_indices = np.argmax(cosine_similarity_matrix, axis=1)
+
+    # Find the maximum similarity value in each row
+    top_match_values = np.amax(cosine_similarity_matrix, axis=1)
+
+    return top_match_indices, top_match_values
+
+
+def top_n_matches(cosine_similarity_matrix: np.ndarray, n: int = 10) -> Tuple[np.ndarray, np.ndarray]:
+    # Find the indices that would sort each row in descending order
+    sorted_indices = np.argsort(-cosine_similarity_matrix, axis=1)
+
+    # Take the first n indices from the sorted indices to get the top n matches
+    top_n_indices = sorted_indices[:, :n]
+
+    # Take the first n values from the sorted values to get the top n match values
+    top_n_values = -np.sort(-cosine_similarity_matrix, axis=1)[:, :n]
+
+    return top_n_indices, top_n_values
+
+
+def mmr_diversified_search(
+    query_vector: np.ndarray, document_vectors: List[np.ndarray], relevance_factor=0.5, top_n=None
+) -> List[int]:
+    """
+    Perform diversified search using Maximal Marginal Relevance (MMR).
+
+    :param query_vector: The vector representing the query.
+    :param document_vectors: The vectors representing the documents.
+    :param relevance_factor: The balance parameter between relevance and diversity.
+    :param top_n: The number of results to return. If None, return all.
+    :return: A list of indices representing the diversified order of documents.
+    """
+    if top_n is None:
+        # If no specific number of results is specified, return all
+        top_n = len(document_vectors)
+
+    if top_n == 0:
+        return []
+
+    # Calculate cosine similarities between query and all documents
+    norms_query = np.linalg.norm(query_vector)
+    norms_docs = np.linalg.norm(document_vectors, axis=1)
+    similarities = np.dot(document_vectors, query_vector) / (norms_docs * norms_query)
+
+    # Initialize set of selected indices and results list
+    selected_indices = set()
+    result_indices = []
+
+    # Diversified search loop
+    for _ in range(top_n):
+        max_mmr = float("-inf")
+        best_index = None
+
+        # Loop over all documents
+        for idx, _doc_vector in enumerate(document_vectors):
+            if idx not in selected_indices:
+                relevance = relevance_factor * similarities[idx]
+                diversity = 0
+
+                # Penalize based on similarity to already selected documents
+                if selected_indices:
+                    max_sim_to_selected = max(
+                        [
+                            np.dot(document_vectors[idx], document_vectors[s])
+                            / (np.linalg.norm(document_vectors[idx]) * np.linalg.norm(document_vectors[s]))
+                            for s in selected_indices
+                        ]
+                    )
+                    diversity = (1 - relevance_factor) * max_sim_to_selected
+
+                mmr_score = relevance - diversity
+
+                # Update best MMR score and index
+                if mmr_score > max_mmr:
+                    max_mmr = mmr_score
+                    best_index = idx
+
+        # Add the best document to the result and mark it as selected
+        if best_index is None:
+            logger.warning(f"No best index found over {len(document_vectors)} documents.")
+            continue
+        result_indices.append(best_index)
+        selected_indices.add(best_index)
+
+    return result_indices

linkml_store/webapi/html/__init__.py

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

linkml_store/webapi/html/base.html.j2

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}LinkML Store API{% endblock %}</title>
+    <style>
+        body { font-family: Arial, sans-serif; line-height: 1.6; padding: 20px; }
+        h1 { color: #333; }
+        a { color: #0066cc; }
+        .navigation { margin-bottom: 20px; }
+        .content { margin-top: 20px; }
+    </style>
+</head>
+<body>
+    <div class="navigation">
+        <a href="/pages/">Home</a> |
+        <a href="/pages/databases">Databases</a>
+    </div>
+    <div class="content">
+        {% block content %}{% endblock %}
+    </div>
+</body>
+</html>

linkml_store/webapi/html/collection_details.html.j2

@@ -0,0 +1,15 @@
+{% extends "base.html.j2" %}
+
+{% block content %}
+<h1>{{ response.meta.title }}</h1>
+<p>Name: {{ params.collection_name }}</p>
+
+<h2>Collections</h2>
+<ul>
+{% for collection in response.data.collections %}
+    <li>
+        <a href="/pages{{ collection.links|selectattr('rel', 'equalto', 'self')|first|attr('href') }}">{{ collection.name }}</a>
+    </li>
+{% endfor %}
+</ul>
+{% endblock %}

linkml_store/webapi/html/database_details.html.j2

@@ -0,0 +1,16 @@
+{% extends "base.html.j2" %}
+
+{% block content %}
+<h1>{{ response.meta.title }}</h1>
+<p>Handle: {{ response.data.handle }}</p>
+<p>Number of collections: {{ response.data.num_collections }}</p>
+
+<h2>Collections</h2>
+<ul>
+{% for collection in response.data.collections %}
+    <li>
+        <a href="/pages{{ collection.links|selectattr('rel', 'equalto', 'self')|first|attr('href') }}">{{ collection.name }}</a>
+    </li>
+{% endfor %}
+</ul>
+{% endblock %}

linkml_store/webapi/html/databases.html.j2

@@ -0,0 +1,14 @@
+{% extends "base.html.j2" %}
+
+{% block title %}LinkML Store API - Databases{% endblock %}
+
+{% block content %}
+<h1>Databases</h1>
+<ul>
+{% for db in response.data.databases %}
+    <li>
+        <a href="/pages/databases/{{ db.name }}">{{ db.name }}</a>
+    </li>
+{% endfor %}
+</ul>
+{% endblock %}