linkml-store 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

linkml_store/cli.py

@@ -16,6 +16,7 @@ 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, write_output
 from linkml_store.utils.object_utils import object_path_update
+from linkml_store.utils.pandas_utils import facet_summary_to_dataframe_unmelted
 
 index_type_option = click.option(
     "--index-type",
@@ -87,6 +88,7 @@ include_internal_option = click.option("--include-internal/--no-include-internal
 @click.option("--set", help="Metadata settings in the form PATHEXPR=value", multiple=True)
 @click.option("-v", "--verbose", count=True)
 @click.option("-q", "--quiet/--no-quiet")
+@click.option("--base-dir", "-B", help="Base directory for the client configuration")
 @click.option(
     "--stacktrace/--no-stacktrace",
     default=False,
@@ -94,7 +96,7 @@ include_internal_option = click.option("--include-internal/--no-include-internal
     help="If set then show full stacktrace on error",
 )
 @click.pass_context
-def cli(ctx, verbose: int, quiet: bool, stacktrace: bool, database, collection, config, set):
+def cli(ctx, verbose: int, quiet: bool, stacktrace: bool, database, collection, config, set, **kwargs):
     """A CLI for interacting with the linkml-store."""
     if not stacktrace:
         sys.tracebacklimit = 0
@@ -117,7 +119,7 @@ def cli(ctx, verbose: int, quiet: bool, stacktrace: bool, database, collection,
     if quiet:
         logger.setLevel(logging.ERROR)
     ctx.ensure_object(dict)
-    client = Client().from_config(config) if config else Client()
+    client = Client().from_config(config, **kwargs) if config else Client()
     settings = ContextSettings(client=client, database_name=database, collection_name=collection)
     ctx.obj["settings"] = settings
     # DEPRECATED
@@ -150,7 +152,7 @@ def cli(ctx, verbose: int, quiet: bool, stacktrace: bool, database, collection,
         #    raise ValueError("Collection must be specified if there are multiple collections.")
         if settings.database and settings.database.list_collections():
             collection = settings.database.list_collections()[0]
-            settings.collection_name = collection.name
+            settings.collection_name = collection.alias
 
 
 @cli.command()
@@ -159,7 +161,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:
@@ -172,15 +182,15 @@ def insert(ctx, files, object, format):
             objects = load_objects(file_path, format=format)
         else:
             objects = load_objects(file_path)
-        logger.info(f"Inserting {len(objects)} objects from {file_path} into collection '{collection.name}'.")
+        logger.info(f"Inserting {len(objects)} objects from {file_path} into collection '{collection.alias}'.")
         collection.insert(objects)
-        click.echo(f"Inserted {len(objects)} objects from {file_path} into collection '{collection.name}'.")
+        click.echo(f"Inserted {len(objects)} objects from {file_path} into collection '{collection.alias}'.")
     if object:
         for object_str in object:
             logger.info(f"Parsing: {object_str}")
             objects = yaml.safe_load(object_str)
             collection.insert(objects)
-            click.echo(f"Inserted {len(objects)} objects from {object_str} into collection '{collection.name}'.")
+            click.echo(f"Inserted {len(objects)} objects from {object_str} into collection '{collection.alias}'.")
     collection.commit()
 
 
@@ -316,7 +326,7 @@ def query(ctx, where, limit, output_type, output):
     """
     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)
+    query = Query(from_table=collection.alias, where_clause=where_clause, limit=limit)
     result = collection.query(query)
     output_data = render_output(result.rows, output_type)
     if output:
@@ -333,7 +343,7 @@ def query(ctx, where, limit, output_type, output):
 def list_collections(ctx, **kwargs):
     db = ctx.obj["settings"].database
     for collection in db.list_collections(**kwargs):
-        click.echo(collection.name)
+        click.echo(collection.alias)
         click.echo(render_output(collection.metadata))
 
 
@@ -343,8 +353,9 @@ def list_collections(ctx, **kwargs):
 @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.option("--columns", "-S", help="Columns to facet on")
+@click.option("--wide/--no-wide", "-U/--no-U", default=False, show_default=True, help="Wide table")
 @click.pass_context
-def fq(ctx, where, limit, columns, output_type, output):
+def fq(ctx, where, limit, columns, output_type, wide, output):
     """
     Query facets from the specified collection.
 
@@ -371,11 +382,22 @@ def fq(ctx, where, limit, columns, output_type, output):
             return "+".join([str(x) for x in key])
         return key
 
-    count_dict = {}
-    for key, value in results.items():
-        value_as_dict = {_untuple(v[0:-1]): v[-1] for v in value}
-        count_dict[_untuple(key)] = value_as_dict
-    output_data = render_output(count_dict, output_type)
+    if wide:
+        results_obj = facet_summary_to_dataframe_unmelted(results)
+    else:
+        if output_type == Format.PYTHON.value:
+            results_obj = results
+        elif output_type in [Format.TSV.value, Format.CSV.value]:
+            results_obj = []
+            for fc, data in results.items():
+                for v, c in data:
+                    results_obj.append({"facet": fc, "value": v, "count": c})
+        else:
+            results_obj = {}
+            for key, value in results.items():
+                value_as_dict = {_untuple(v[0:-1]): v[-1] for v in value}
+                results_obj[_untuple(key)] = value_as_dict
+    output_data = render_output(results_obj, output_type)
     if output:
         with open(output, "w") as f:
             f.write(output_data)
@@ -395,14 +417,17 @@ def _get_index(index_type=None, **kwargs) -> Indexer:
 @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.option(
+    "--limit", "-l", default=-1, show_default=True, type=click.INT, help="Maximum number of results to return"
+)
 @click.pass_context
-def describe(ctx, where, output_type, output):
+def describe(ctx, where, output_type, output, limit):
     """
     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
+    df = collection.find(where_clause, limit=limit).rows_dataframe
     write_output(df.describe(include="all").transpose(), output_type, target=output)
 
 
@@ -460,7 +485,7 @@ def search(ctx, search_term, where, limit, index_type, output_type, output, auto
     """Search objects in the specified collection."""
     collection = ctx.obj["settings"].collection
     ix = get_indexer(index_type)
-    logger.info(f"Attaching index to collection {collection.name}: {ix.model_dump()}")
+    logger.info(f"Attaching index to collection {collection.alias}: {ix.model_dump()}")
     collection.attach_indexer(ix, auto_index=auto_index)
     result = collection.search(search_term, where=where, limit=limit)
     output_data = render_output([{"score": row[0], **row[1]} for row in result.ranked_rows], output_type)
@@ -490,6 +515,7 @@ def indexes(ctx):
 def validate(ctx, output_type, output):
     """Validate objects in the specified collection."""
     collection = ctx.obj["settings"].collection
+    logger.info(f"Validating collection {collection.alias}")
     validation_results = [json_dumper.to_dict(x) for x in collection.iter_validate_collection()]
     output_data = render_output(validation_results, output_type)
     if output:

linkml_store/index/__init__.py

@@ -1,3 +1,14 @@
+"""
+Indexers package.
+
+Indexers allow indexes to be added to existing :class:`Collection` objects.
+
+Current two are supported:
+
+* simple: :class:`SimpleIndexer`
+* llm: :class:`LLMIndexer`
+"""
+
 from typing import Type
 
 from linkml_store.index.implementations.llm_indexer import LLMIndexer
@@ -14,7 +25,7 @@ def get_indexer_class(name: str) -> Type[Indexer]:
     """
     Get an indexer class by name.
 
-    :param name: the name of the indexer
+    :param name: the name of the indexer (simple, llm, ...)
     :return: the indexer class
     """
     if name not in INDEXER_CLASSES:
@@ -22,16 +33,21 @@ 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.
 
-    :param name: the name of the indexer
+    >>> simple_indexer = get_indexer("simple")
+    >>> llm_indexer = get_indexer("llm")
+
+    :param name: the name of the indexer (simple, llm, ...)
     :param kwargs: additional arguments to pass to the 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/implementations/llm_indexer.py

@@ -74,7 +74,7 @@ class LLMIndexer(Indexer):
 
             embeddings_client = Client()
             config = CollectionConfig(
-                name=coll_name,
+                alias=coll_name,
                 type="Embeddings",
                 attributes={
                     "text": {"range": "string"},
@@ -116,6 +116,7 @@ class LLMIndexer(Indexer):
                     embeddings_collection.insert(
                         {"text": uncached_texts[i], "embedding": embeddings[index], "model_id": model_id}
                     )
+                embeddings_collection.commit()
         else:
             logger.info(f"Embedding {len(texts)} texts")
             embeddings = model.embed_multi(texts)

linkml_store/index/indexer.py

@@ -11,11 +11,22 @@ logger = logging.getLogger(__name__)
 
 
 class TemplateSyntaxEnum(str, Enum):
+    """
+    Template syntax types.
+    """
+
     jinja2 = "jinja2"
     fstring = "fstring"
 
 
-def cosine_similarity(vector1, vector2):
+def cosine_similarity(vector1, vector2) -> float:
+    """
+    Calculate the cosine similarity between two vectors
+
+    :param vector1:
+    :param vector2:
+    :return:
+    """
     dot_product = np.dot(vector1, vector2)
     norm1 = np.linalg.norm(vector1)
     norm2 = np.linalg.norm(vector2)
@@ -24,10 +35,11 @@ def cosine_similarity(vector1, vector2):
 
 class Indexer(BaseModel):
     """
-    An index operates on a collection in order to search for objects.
+    An indexer operates on a collection in order to search for objects.
     """
 
     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 +105,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/file_utils.py

@@ -0,0 +1,37 @@
+import logging
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+def safe_remove_directory(dir_path: Path, no_backup: bool = False) -> Optional[Path]:
+    # Ensure the directory exists
+    if not dir_path.exists():
+        raise FileNotFoundError(f"Directory does not exist: {dir_path}")
+    try:
+        if no_backup:
+            # Move to a temporary directory instead of permanent removal
+            with tempfile.TemporaryDirectory() as tmpdir:
+                tmp_path = Path(tmpdir) / dir_path.name
+                shutil.move(str(dir_path), str(tmp_path))
+                logger.info(f"Directory moved to temporary location: {tmp_path}")
+                # The directory will be automatically removed when exiting the context manager
+            return None
+        else:
+            # Create a backup directory name with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_dir = dir_path.with_name(f"{dir_path.name}_backup_{timestamp}")
+
+            # Move the directory to the backup location
+            shutil.move(str(dir_path), str(backup_dir))
+            logger.info(f"Directory backed up to: {backup_dir}")
+            return backup_dir
+
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        return None

linkml_store/utils/format_utils.py

@@ -7,8 +7,10 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, TextIO, Type, Union
 
 import pandas as pd
+import pystow
 import yaml
 from pydantic import BaseModel
+from tabulate import tabulate
 
 
 class Format(Enum):
@@ -21,12 +23,40 @@ class Format(Enum):
     YAML = "yaml"
     TSV = "tsv"
     CSV = "csv"
+    PYTHON = "python"
     PARQUET = "parquet"
     FORMATTED = "formatted"
+    TABLE = "table"
+
+
+def load_objects_from_url(
+    url: str,
+    format: Union[Format, str] = None,
+    expected_type: Type = None,
+    local_path: Optional[str] = None,
+    **kwargs,
+) -> List[Dict[str, Any]]:
+    """
+    Load objects from a URL in JSON, JSONLines, YAML, CSV, or TSV format.
+
+    :param url: The URL 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.
+    :param local_path: The local path to save the file to.
+    :return: A list of dictionaries representing the loaded objects.
+    """
+    local_path = pystow.ensure("linkml", "linkml-store", url=url)
+    objs = load_objects(local_path, format=format, expected_type=expected_type, **kwargs)
+    if not objs:
+        raise ValueError(f"No objects loaded from URL: {url}")
+    return objs
 
 
 def load_objects(
-    file_path: Union[str, Path], format: Union[Format, str] = None, expected_type: Type = None
+    file_path: Union[str, Path],
+    format: Union[Format, str] = None,
+    expected_type: Type = None,
+    header_comment_token: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """
     Load objects from a file in JSON, JSONLines, YAML, CSV, or TSV format.
@@ -37,7 +67,7 @@ def load_objects(
 
     :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.
+    :param expected_type: The target type to load the objects into, e.g. list
     :return: A list of dictionaries representing the loaded objects.
     """
     if isinstance(format, str):
@@ -48,6 +78,12 @@ def load_objects(
 
     if not format and (file_path.endswith(".parquet") or file_path.endswith(".pq")):
         format = Format.PARQUET
+    if not format and file_path.endswith(".tsv"):
+        format = Format.TSV
+    if not format and file_path.endswith(".csv"):
+        format = Format.CSV
+    if not format and file_path.endswith(".py"):
+        format = Format.PYTHON
 
     mode = "r"
     if format == Format.PARQUET:
@@ -64,15 +100,33 @@ def load_objects(
     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"))):
-        if expected_type and expected_type == list:
+        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)
+    elif format == Format.TSV or format == Format.CSV:
+        # Skip initial comment lines if comment_char is set
+        if header_comment_token:
+            # Store the original position
+            original_pos = f.tell()
+
+            # Read and store lines until we find a non-comment line
+            lines = []
+            for line in f:
+                if not line.startswith(header_comment_token):
+                    break
+                lines.append(line)
+
+            # Go back to the original position
+            f.seek(original_pos)
+
+            # Skip the comment lines we found
+            for _ in lines:
+                f.readline()
+        if format == Format.TSV:
+            reader = csv.DictReader(f, delimiter="\t")
+        else:
+            reader = csv.DictReader(f)
         objs = list(reader)
     elif format == Format.PARQUET:
         import pyarrow.parquet as pq
@@ -151,6 +205,9 @@ def render_output(
     if isinstance(data, pd.DataFrame):
         data = data.to_dict(orient="records")
 
+    if isinstance(data, dict) and format in [Format.TSV, Format.CSV]:
+        data = [data]
+
     if isinstance(data, BaseModel):
         data = data.model_dump()
 
@@ -158,6 +215,10 @@ def render_output(
         return json.dumps(data, indent=2, default=str)
     elif format == Format.JSONL:
         return "\n".join(json.dumps(obj) for obj in data)
+    elif format == Format.PYTHON:
+        return str(data)
+    elif format == Format.TABLE:
+        return tabulate(pd.DataFrame(data), headers="keys", tablefmt="psql")
     elif format == Format.YAML:
         if isinstance(data, list):
             return yaml.safe_dump_all(data, sort_keys=False)

linkml_store/utils/pandas_utils.py

@@ -0,0 +1,40 @@
+from typing import Dict, List, Tuple, Union
+
+import pandas as pd
+
+
+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):
+                    row[facet] = categories[i]
+                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/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/sql_utils.py

@@ -19,8 +19,9 @@ TYPE_MAP = {
 
 OP_MAP = {
     "eq": "=",
+    "$in": "ARRAY_CONTAINS",  ## mongodb
+    "$contains": "ARRAY_CONTAINS",  ## TODO: this is chromadb-specific
     "in": "ARRAY_CONTAINS",
-    "$contains": "ARRAY_CONTAINS",
 }
 
 

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 %}

linkml_store/webapi/html/generic.html.j2

@@ -0,0 +1,46 @@
+{% extends "base.html.j2" %}
+
+{% block title %}{meta.path}{% endblock %}
+
+{% block content %}
+    <h1>Meta</h1>
+        <pre>
+{{ response.meta }}
+        </pre>
+
+    <h1>Links</h1>
+        <ul>
+{% for link in response.links %}
+            <li>
+                <a href="/pages{{ link.href }}">{{ link.rel }} ({{ link.href }})</a>
+            </li>
+{% endfor %}
+    </ul>
+</ul>
+
+    <h1>Data</h1>
+    {% if data_html %}
+        <ul>
+        {% for e in data_html %}
+            <li>{{ e|safe }}</li>
+        {% endfor %}
+        </ul>
+    {% else %}
+
+        {%  if "items" in response.data %}
+        <ul>
+        {% for item in response.data['items'] %}
+            <li>
+                {{ item.name }}
+                {% for link in item.links %}
+                    <a href="/pages{{ link.href }}">{{ link.rel }}</a>
+                {% endfor %}
+            </li>
+        {% endfor %}
+        </ul>
+        {%  endif %}
+        <pre>
+{{ response.data }}
+        </pre>
+    {% endif %}
+{% endblock %}